class AlarmVar(db.Model):
__tablename__ = 'alarm_vars'
id = db.Column(db.Integer, primary_key=True)
alarm_id = db.Column(db.Integer, db.ForeignKey("alarms.id"))
name = db.Column(db.String(60))
value = db.Column(db.String(100))
alarm = db.relationship('Alarm', backref=db.backref('vars', order_by=id))
class Vendor(db.Model):
"""Device Vendor"""
__tablename__ = 'vendors'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
type_id = db.Column(db.Integer) # 貌似没用?
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
url = db.Column(db.String(100)) # 厂商主页
is_valid = db.Column(db.Integer)
models = db.relationship("Model", backref="vendor")
@property
def node_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(Node.vendor_id==self.id)
)
@property
def node_status1_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 1))
)
@property
def node_status2_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 2))
)
@property
def node_status3_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 3))
)
@property
def node_status4_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 4))
)
def __unicode__(self):
return u'<厂商 %s>' % self.alias
class Manager(db.Model):
"""EMS"""
__tablename__ = 'managers'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
dn = db.Column(db.String(100))
name = db.Column(db.String(40))
alias = db.Column(db.String(100))
addr = db.Column(db.String(100))
status = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
class AlarmJournal(db.Model):
__tablename__ = 'alarm_journals'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
alarm_id = db.Column(db.Integer, db.ForeignKey("alarms.id"))
title = db.Column(db.String(200))
summary = db.Column(db.String(200))
created_at = db.Column(db.DateTime)
user = db.relationship('User')
alarm = db.relationship('Alarm', backref=db.backref('journals', order_by=id))
class NodeEoc(NodeMixin, db.Model):
""" Eocs """
__tablename__ = 'node_eocs'
esn = db.Column(db.String(50)) # ESN
contact_tel = db.Column(db.String(50)) # 联系电话
install_time = db.Column(db.DateTime) # 安装时间
ctrl_id = db.Column(db.Integer, db.ForeignKey('node_onus.id'))
cpes = db.relationship("NodeCpe", backref="eoc")
ports = db.relationship("PortEoc", backref="eoc")
@property
def cpe_count_plan(self):
return object_session(self).\
scalar(
select([func.count(NodeCpe.id)]).\
where(and_(NodeCpe.ctrl_id==self.id, NodeCpe.area_id != None))
)
@property
def cpe_count_unplan(self):
return object_session(self).\
scalar(
select([func.count(NodeCpe.id)]).\
where(and_(NodeCpe.ctrl_id==self.id, NodeCpe.area_id == None))
)
def __unicode__(self):
return u'<EOC %s>' % self.alias
@staticmethod
def export_columns():
return [
'name', 'alias', 'addr', 'area.branch_name', 'vendor.alias',
'mask', 'snmp_comm', 'snmp_wcomm', 'snmp_ver', 'remark'
]
@staticmethod
def eoc_entrance():
eoc_entrance = db.session.query(NodeEoc.addr, Area.alias).outerjoin(
Area,
Area.branch == NodeEoc.area_id).filter(Area.area_type == 4).all()
eoc_entrance_dict = {}
for ip, entrance_name in eoc_entrance:
if eoc_entrance_dict.get(ip):
eoc_entrance_dict[ip] = eoc_entrance_dict[ip] + [entrance_name]
else:
eoc_entrance_dict[ip] = [entrance_name]
return eoc_entrance_dict
class Module(db.Model):
"""采集模块表"""
__tablename__ = 'modules'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
alias = db.Column(db.String(40))
period = db.Column(db.Integer) # 采集周期, 单位: minute
retries = db.Column(db.Integer) # 重试次数, 单位: 次
timeout = db.Column(db.Integer) # 超时, 单位: second
remark = db.Column(db.String(100))
def __unicode__(self):
return u'<采集模块 %s>' % self.alias
class SysOid(db.Model):
"""设备系统OID"""
__tablename__ = 'sysoids'
id = db.Column(db.Integer, primary_key=True)
sysoid = db.Column(db.String(100))
model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
disco = db.Column(db.String(20)) # 发现模块
mib = db.Column(db.String(20)) # mib文件, 从 miboids.mib 中选
remark = db.Column(db.String(100))
model = db.relation('Model')
def __unicode__(self):
return u'<SysOid %s>' % self.sysoid
class SubSystem(db.Model):
""" 子采集 """
__tablename__ = 'subsystems'
id = db.Column(db.Integer, primary_key=True)
rdn = db.Column(db.String(100))
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
host = db.Column(db.String(100))
status = db.Column(db.Integer)
descr = db.Column(db.String(200))
started_at = db.Column(db.DateTime) # 启动采集的时间
updated_at = db.Column(db.DateTime, onupdate=datetime.now)
def __unicode__(self):
return u'<子采集 %s>' % self.alias
class AlarmKnowledge(db.Model):
__tablename__ = 'alarm_knowledges'
id = db.Column(db.Integer, primary_key=True)
class_id = db.Column(db.Integer, db.ForeignKey("alarm_classes.id"))
probable_cause = db.Column(db.String(200))
resolvent = db.Column(db.String(200))
probability = db.Column(db.Integer)
apply_count = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
alarm_class = db.relation('AlarmClass')
def __unicode__(self):
return u'<告警知识库 %s>'% self.alarm_alias
class OperationLog(db.Model):
__tablename__ = 'oplogs'
id = db.Column(db.Integer, primary_key=True)
session = db.Column(db.String(50))
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
action = db.Column(db.String(200))
success = db.Column(db.Integer)
summary = db.Column(db.String(200))
module = db.Column(db.String(200))
terminal_ip = db.Column(db.String(20))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
user = db.relationship("User")
def __unicode__(self):
return u'<操作日志 %s>' % self.user.name
class TimePeriod(db.Model):
"""采集规则"""
__tablename__ = 'timeperiods'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
minute = db.Column(db.String(100))
_hour = db.Column('hour', db.String(60), default='*')
_dayofmonth = db.Column('dayofmonth', db.String(100), default='*')
_month = db.Column('month', db.String(40), default='*')
_dayofweek = db.Column('dayofweek', db.String(40), default='*')
start_at = db.Column(db.DateTime)
end_at = db.Column(db.DateTime)
state_in = db.Column(db.Integer)
state_out = db.Column(db.Integer)
status = db.Column(db.Integer)
remark = db.Column(db.String(200))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __unicode__(self):
return u'<采集规则 %s>' % self.alias
@property
def hour(self):
return self._hour.split(',')
@hour.setter
def hour(self, lst):
self._hour = ','.join(lst)
@property
def dayofmonth(self):
return self._dayofmonth.split(',')
@dayofmonth.setter
def dayofmonth(self, lst):
self._dayofmonth = ','.join(lst)
@property
def month(self):
return self._month.split(',')
@month.setter
def month(self, lst):
self._month = ','.join(lst)
@property
def dayofweek(self):
return self._dayofweek.split(',')
@dayofweek.setter
def dayofweek(self, lst):
self._dayofweek = ','.join(lst)
class Threshold(db.Model):
'''阀值表'''
__tablename__ = 'thresholds'
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
metric_id = db.Column(db.Integer, db.ForeignKey('metrics.id'))
name = db.Column(db.String(60)) # 后台生成
alias = db.Column(db.String(100))
enabled = db.Column(db.Integer, default=1)
alarm_class_id = db.Column(db.Integer, db.ForeignKey('alarm_classes.id'))
occur_count = db.Column(db.Integer, default=1)
summary = db.Column(db.String(200))
occur_cond1 = db.Column(db.String(60))
restore_cond1 = db.Column(db.String(60))
severity1 = db.Column(db.Integer, db.ForeignKey('alarm_severities.id'), default=4 )
occur_cond2 = db.Column(db.String(60))
restore_cond2 = db.Column(db.String(60))
severity2 = db.Column(db.Integer, db.ForeignKey('alarm_severities.id'), default=2)
severity1_obj = db.relationship('AlarmSeverity',
primaryjoin="AlarmSeverity.id==Threshold.severity1")
severity2_obj = db.relationship('AlarmSeverity',
primaryjoin="AlarmSeverity.id==Threshold.severity2")
category = db.relationship('Category')
metric = db.relationship('Metric')
alarm_class = db.relationship('AlarmClass')
def __unicode__(self):
return u'<阀值 %s>' % self.alias
class Area(db.Model):
"""
Area Table
"""
__tablename__ = 'areas'
id = db.Column(db.Integer, primary_key=True)
parent_id = db.Column(db.Integer, db.ForeignKey('areas.id'))
dn = db.Column(db.String(100))
name = db.Column(db.String(50))
alias = db.Column(db.String(100))
area_type = db.Column(db.Integer)
longitude = db.Column(db.Float)
latitude = db.Column(db.Float)
address = db.Column(db.String(100))
order_seq = db.Column(db.Integer)
managed_status = db.Column(db.Integer)
entrance_type = db.Column(db.Integer)
sub_type = db.Column(db.Integer)
entrance_level = db.Column(db.Integer)
check_state = db.Column(db.Integer)
entrance = db.Column(db.Integer)
entrance_name = db.Column(db.String(50))
branch = db.Column(db.Integer)
branch_name = db.Column(db.String(50))
town = db.Column(db.Integer)
town_name = db.Column(db.String(50))
cityid = db.Column(db.Integer)
city_name = db.Column(db.String(50))
remark = db.Column(db.String(50))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime, default=datetime.now)
children = db.relation(
'Area',
backref=backref("parent", remote_side=id),
)
@hybrid_property
def full_name(self):
name_list = [
self.city_name, self.town_name, self.branch_name,
self.entrance_name
]
fname = ' / '.join([name for name in name_list if name])
return self.name if fname == '' else fname
def __unicode__(self):
return u'<区域 %r>' % self.alias
class Role(db.Model):
"""角色表"""
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
description = db.Column(db.String(100))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
permissions = db.relation('Permission', backref="roles", secondary=roles_permissions)
def __repr__(self):
return '<Role%r>' % self.name
def __unicode__(self):
return u'<角色 %s>' % self.name
class NodeCpe(NodeMixin, db.Model):
""" Cpes """
__tablename__ = 'node_cpes'
esn = db.Column(db.String(50)) # ESN
contact_tel = db.Column(db.String(50)) # 联系电话
install_time = db.Column(db.DateTime) # 安装时间
card_id = db.Column(db.String(50)) # 身份证号
ctrl_id = db.Column(db.Integer, db.ForeignKey('node_eocs.id'))
def __unicode__(self):
return u'<CPE %s>' % self.alias
@staticmethod
def export_columns():
return [
'name', 'alias', 'mac', 'eoc.addr', 'area.entrance_name',
'snmp_comm', 'snmp_wcomm', 'snmp_ver', 'remark'
]
class Maintain(db.Model):
"""维护人信息"""
__tablename__ = 'maintains'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
name = db.Column(db.String(40))
alias = db.Column(db.String(100))
department = db.Column(db.String(40))
phone = db.Column(db.String(40))
mobile = db.Column(db.String(40))
email = db.Column(db.String(50))
post_addr = db.Column(db.String(50))
post_code = db.Column(db.String(50))
admin = db.Column(db.String(50))
remark = db.Column(db.String(100))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __unicode__(self):
return u'<维护人 %s>' % self.alias
class PortMixin(object):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
alias = db.Column(db.String(40))
board_id = db.Column(db.Integer)
# 业务端口类型， 1.FE 2.GE 3.PON 4.POTS 5.DSL 6.E1 7.SDH 8.RF 9.VI 10.AGGREGATION
biztype = db.Column(db.Integer)
ifindex = db.Column(db.Integer) # 端口索引
ifdescr = db.Column(db.String(100)) # 端口名称
iftype = db.Column(db.Integer) # 端口物理类型
ifphysaddr = db.Column(db.String(50)) # 端口物理地址
ifadminstatus = db.Column(db.Integer) # 管理状态
ifoperstatus = db.Column(db.Integer) # 运行状态
ifspeed = db.Column(db.Integer) # 端口速率
ifmtu = db.Column(db.Integer) # 端口MTU
iflastchange = db.Column(db.DateTime) # 端口最后变化时间
uplink_port = db.Column(db.Integer) # 上联端口
slot_no = db.Column(db.Integer) # 槽位号
port_no = db.Column(db.Integer) # 端口号
downassuredbw = db.Column(db.Integer) # 下行限速
downmaximumbw = db.Column(db.Integer) # 下行带宽
upassuredbw = db.Column(db.Integer) # 上行限速
upmaximumbw = db.Column(db.Integer) # 上行带宽
temperature = db.Column(db.Integer) # 温度
received_power = db.Column(db.Integer) # 接受功率
led_power = db.Column(db.Integer) # 发光功率
e_current = db.Column(db.Integer) # 电流
voltage = db.Column(db.Integer) # 电压
telno = db.Column(db.String(50))
duplex = db.Column(db.Integer) # 双工状态
tid = db.Column(db.String(50)) # 协议终端标识
physaddress = db.Column(db.String(50))
mgid = db.Column(db.String(20))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
@declared_attr
def category_id(cls):
return db.Column(db.Integer, db.ForeignKey('categories.id'))
@declared_attr
def category(cls):
return db.relationship("Category")
@declared_attr
def vendor_id(cls):
return db.Column(db.Integer, db.ForeignKey('vendors.id'))
@declared_attr
def vendor(cls):
return db.relationship("Vendor")
class Model(db.Model):
"""设备型号"""
__tablename__ = 'models'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
object = db.Column(db.String(100)) # 不要
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
sysoid = db.Column(db.String(100))
vendor_id = db.Column(db.Integer, db.ForeignKey("vendors.id"))
fttx = db.Column(db.Integer) # 不要
control_slot_num = db.Column(db.Integer) # 不要
business_slot_num = db.Column(db.Integer) # 不要
is_valid = db.Column(db.Integer)
remark = db.Column(db.String(100))
category = db.relation('Category')
def __unicode__(self):
return u'<型号 %s>' % self.alias
class Server(db.Model):
"""Servers of the system"""
__tablename__ = 'servers'
id = db.Column(db.Integer, primary_key=True)
dn = db.Column(db.String(200))
jid = db.Column(db.String(200))
name = db.Column(db.String(100))
os_type = db.Column(db.String(100))
addrs = db.Column(db.String(200))
cpu_info = db.Column(db.String(200))
mem_info = db.Column(db.String(200))
swap_info = db.Column(db.String(200))
disk_info = db.Column(db.String(200))
worker_num = db.Column(db.Integer)
presence = db.Column(db.Integer)
descr = db.Column(db.String(200))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __unicode__(self):
return u'<服务器 %s>' % self.name
class AlarmClass(db.Model):
"""告警类型表"""
__tablename__ = 'alarm_classes'
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
name = db.Column(db.String(60))
alias = db.Column(db.String(60))
severity = db.Column(db.Integer)
probable_cause = db.Column(db.String(200))
specific_problem = db.Column(db.String(200))
additional_info = db.Column(db.String(200))
remark = db.Column(db.String(100))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
category = db.relation('Category')
def __repr__(self):
return '<AlarmClass %r>' % self.name
def __unicode__(self):
return u'<告警类型 %s>'% self.alias
class SecurityLog(db.Model):
__tablename__ = 'seclogs'
id = db.Column(db.Integer, primary_key=True)
session = db.Column(db.String(50))
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
success = db.Column(db.Integer)
summary = db.Column(db.String(200))
terminal_ip = db.Column(db.String(20))
login_at = db.Column(db.DateTime)
logout_at = db.Column(db.DateTime)
user = db.relationship("User")
@hybrid_property
def time(self):
if u'登录' in self.summary:
return self.login_at
else:
return self.logout_at
def __unicode__(self):
return u'<安全日志 %s>' % self.user.name
class AlarmSeverity(db.Model):
__tablename__ = 'alarm_severities'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
alias = db.Column(db.String(60))
color = db.Column(db.String(60))
sound = db.Column(db.String(60))
remark = db.Column(db.String(60))
@property
def count(self):
from tango.login import current_user
from nodes.models import Node, Area
query = object_session(self).query(func.count(Alarm.id)).filter(Alarm.severity == self.id)
if not current_user.is_province_user:
query = query.outerjoin(Node, Node.id == Alarm.node_id)
query = query.outerjoin(Area, Area.id == Node.area_id)
query = query.filter(current_user.domain.clause_permit)
return query.scalar()
@staticmethod
def name2id(name):
name_dict = {
'clear' : 0,
'indeterminate' : 1,
'warning' : 2,
'minor' : 3,
'major' : 4,
'critical' : 5
}
return name_dict[name] if name in name_dict else -1
def __repr__(self):
return '<Severity%r>' % self.name
def __unicode__(self):
return u'<告警级别 %s>' % self.alias
class UserGroup(db.Model):
"""用户组"""
__tablename__ = 'user_groups'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
domain_id = db.Column(db.Integer, db.ForeignKey('domains.id'))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
role = db.relation('Role')
domain = db.relation('Domain')
def __unicode__(self):
return u'<用户组 %s>' % self.name
class Metric(db.Model):
''' 指标管理 '''
__tablename__ = 'metrics'
id = db.Column(db.Integer, primary_key=True)
grp = db.Column(db.String(60))
name = db.Column(db.String(60))
alias = db.Column(db.String(100))
calc = db.Column(db.String(60))
unit = db.Column(db.String(200))
format = db.Column(db.String(200))
descr = db.Column(db.String(200))
def __unicode__(self):
return u'<指标 %s>' % self.alias
class Board(db.Model):
"""板卡"""
__tablename__ = 'boards'
node_id = db.Column(db.Integer)
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
alias = db.Column(db.String(40))
vendor_id = db.Column(db.Integer) # 厂商
shelf_no = db.Column(db.Integer) # 机架号
slot_no = db.Column(db.Integer) # 槽位号
board_no = db.Column(db.Integer) # 板卡号
board_type = db.Column(db.Integer) # 板卡类型
board_status = db.Column(db.Integer) # 板卡状态
software_vsn = db.Column(db.String(200)) #软件版本
hardversion = db.Column(db.String(200)) #硬件版本
fpga_vsn = db.Column(db.String(100)) #FPGA版本
cpld_vsn = db.Column(db.String(100)) #CPLD版本
max_ports = db.Column(db.Integer) # 端口数量
adminstatus = db.Column(db.Integer) # 管理状态
operstatus = db.Column(db.Integer) # 运行状态
standbystatus = db.Column(db.Integer) #主备状态
lockstatus = db.Column(db.Integer) # 锁状态
cpuload = db.Column(db.Integer) # CPU负载
memusage = db.Column(db.Integer) # 内存占用
temperature = db.Column(db.Integer) # 温度
serial_no = db.Column(db.String(100)) # 序列号
uptime = db.Column(db.Integer) # 运行时间
remark = db.Column(db.String(100))
last_update = db.Column(db.DateTime)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
category = db.relationship("Category")
@property
def port_count(self):
return object_session(self).\
scalar(
select([func.count(Port.id)]).\
where(Port.board_id==self.id)
)
class NodeHost(NodeMixin, db.Model):
""" Hosts """
__tablename__ = 'node_hosts'
os_type = db.Column(db.String(100))
ifaces = db.Column(db.String(200)) #
cpu_info = db.Column(db.String(200))
mem_info = db.Column(db.String(200))
swap_info = db.Column(db.String(200))
disk_info = db.Column(db.String(200))
worker_num = db.Column(db.Integer) # 采集进程数
def __unicode__(self):
return u'<服务器 %s>' % self.alias
class Miboid(db.Model):
"""Mib 文件"""
__tablename__ = 'miboids'
id = db.Column(db.Integer, primary_key=True)
mib = db.Column(db.String(100))
grp = db.Column(db.String(40))
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
oid = db.Column(db.String(100))
is_valid = db.Column(db.Integer)
remark = db.Column(db.String(100))
def __unicode__(self):
return u'<Mib %s>' % self.alias
class Monitor(db.Model):
"""监控器表"""
__tablename__ = 'monitors'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(20)) # 分类, 不关联
vendor = db.Column(db.String(20)) # 厂商,
sysoid = db.Column(db.String(100)) # 不关联
match = db.Column(db.String(100)) # 匹配规则
modid = db.Column(db.Integer, db.ForeignKey('modules.id'))
mib = db.Column(db.String(20))
remark = db.Column(db.String(100))
module = db.relation('Module')
def __unicode__(self):
return u'<监控器>'
class History(db.Model):
__tablename__ = 'histories'
id = db.Column(db.Integer, primary_key=True)
alarm_key = db.Column(db.String(200))
alarm_class = db.Column(db.String(60))
alarm_name = db.Column(db.String(60))
alarm_alias = db.Column(db.String(200))
alarm_state = db.Column(db.Integer)
manager = db.Column(db.String(60))
agent = db.Column(db.String(60))
node_id = db.Column(db.Integer, db.ForeignKey('nodes.id'))
node_class = db.Column(db.Integer)
node_alias = db.Column(db.String(200))
node_addr = db.Column(db.String(100))
node_managed_state = db.Column(db.Integer)
node_prod_state = db.Column(db.Integer)
source = db.Column(db.String(60))
source_class = db.Column(db.String(60))
severity = db.Column(db.Integer)
summary = db.Column(db.String(200))
state_change = db.Column(db.DateTime)
first_occurrence = db.Column(db.DateTime)
last_occurrence = db.Column(db.DateTime)
occur_count = db.Column(db.Integer)
priority = db.Column(db.Integer)
graded = db.Column(db.Integer)
location = db.Column(db.String(100))
service = db.Column(db.String(100))
customer = db.Column(db.String(100))
sequence_no = db.Column(db.Integer)
x733_type = db.Column(db.Integer)
probable_cause = db.Column(db.String(200))
specific_problem = db.Column(db.String(200))
additional_information = db.Column(db.String(200))
proposed_repaire_action = db.Column(db.String(200))
acked = db.Column(db.Integer)
acked_user = db.Column(db.String(60))
acked_time = db.Column(db.DateTime)
acked_note = db.Column(db.String(60))
cleared = db.Column(db.Integer)
cleared_user = db.Column(db.String(60))
cleared_time = db.Column(db.DateTime)
cleared_note = db.Column(db.String(100))
order_state = db.Column(db.Integer)
root_cause = db.Column(db.Integer)
cause_type = db.Column(db.Integer)
extended_attrs = db.Column(db.Text)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
#node = db.relation('Node', backref=db.backref("histories"))
def __unicode__(self):
return u'<历史告警 %s>'% self.alarm_alias
class NodeMixin(object):
id = db.Column(db.Integer, primary_key=True)
dn = db.Column(db.String(100))
name = db.Column(db.String(40))
alias = db.Column(db.String(200))
addr = db.Column(db.String(20))
mask = db.Column(db.String(60))
mac = db.Column(db.String(20))
#-- 0:不可用 1:可用
status = db.Column(db.Integer)
#-- 0:未管理 1:已管理
managed_state = db.Column(db.Integer)
#-- 0:Production 1:Pre-Production 2:Test 3:Maintenance 4:Decommissioned
prod_state = db.Column(db.Integer)
remark = db.Column(db.String(200))
#-- 1:PON 2:WLAN 3:DATA 4:SERVER 5:CPE 6:ACCESS
business = db.Column(db.Integer)
group_id = db.Column(db.Integer)
summary = db.Column(db.String(255))
location = db.Column(db.String(200))
owner = db.Column(db.String(40))
snmp_port = db.Column(db.Integer)
snmp_ver = db.Column(db.String(20))
snmp_comm = db.Column(db.String(40))
snmp_wcomm = db.Column(db.String(40))
sysoid = db.Column(db.String(100))
sysname = db.Column(db.String(40))
sysdescr = db.Column(db.String(200))
sysuptime = db.Column(db.DateTime)
#oid_idx = db.Column(db.String(100)) # 节点的oid索引
sysmodel = db.Column(db.String(100))
os_version = db.Column(db.String(40))
agent = db.Column(db.String(100))
manager = db.Column(db.String(100))
extra = db.Column(db.String(255))
last_check = db.Column(db.DateTime)
next_check = db.Column(db.DateTime)
duration = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
snmp_status = db.Column(db.Integer) # snmp状态
snmp_summary = db.Column(db.String(400)) # snmp状态详细
ping_status = db.Column(db.Integer) # ping状态
ping_summary = db.Column(db.String(400)) # ping状态详细
#-- 20:olt 21:onu 30:dslam 50:eoc 2:switch 90:host
@declared_attr
def category_id(cls):
return db.Column(db.Integer, db.ForeignKey('categories.id'))
@declared_attr
def category(cls):
return db.relationship("Category")
@declared_attr
def maintainer_id(cls):
return db.Column(db.Integer, db.ForeignKey('maintains.id'))
@declared_attr
def maintain(cls):
return db.relationship("Maintain")
@declared_attr
def area_id(cls):
return db.Column(db.Integer, db.ForeignKey('areas.id'))
@declared_attr
def area(cls):
return db.relationship("Area")
@declared_attr
def timeperiod_id(cls):
return db.Column(db.Integer, db.ForeignKey('timeperiods.id'))
@declared_attr
def timeperiod(cls):
return db.relationship("TimePeriod")
@declared_attr
def vendor_id(cls):
return db.Column(db.Integer, db.ForeignKey('vendors.id'))
@declared_attr
def vendor(cls):
return db.relationship("Vendor")
@declared_attr
def model_id(cls):
return db.Column(db.Integer, db.ForeignKey('models.id'))
@declared_attr
def model(cls):
return db.relationship("Model")
@hybrid_property
def cityid(self):
return self.area.cityid
@hybrid_property
def town(self):
return self.area.town
@hybrid_property
def branch(self):
return self.area.branch
@hybrid_property
def entrance(self):
return self.area.entrance
@hybrid_property
def status_name(self):
return NODE_STATUS_DICT.get(self.status, "")
@hybrid_property
def ping_status_name(self):
return ping_status_dict.get(self.ping_status, "")
@hybrid_property
def snmp_status_name(self):
return snmp_status_dict.get(self.snmp_status, "")
@property
def boards(self):
return Board.query.filter(Board.node_id == self.id)
