class Attr(db.Model):
attrid = db.Column(db.Integer, primary_key=True)
attrname = db.Column(db.String(80))
attrvalue = db.Column(db.String(80))
displaytablerow_id = db.Column(
db.Integer, db.ForeignKey('displaytablerow.displaytablerowid'))
chartconfig_id = db.Column(db.Integer,
db.ForeignKey('chartconfig.chartconfigid'))
operation_id = db.Column(db.Integer,
db.ForeignKey('operation.operationid'))
def __init__(self,
attrname,
attrvalue,
displaytablerow=None,
chartconfig=None,
operation=None):
self.attrname = attrname
self.attrvalue = attrvalue
self.displaytablerow = displaytablerow
self.chartconfig = chartconfig
self.operation = operation
def __repr__(self):
return '<Attr key: %r value: %r>' % (self.attrname, self.attrvalue)
class Selectedmetrics(db.Model):
selectedmetricsid = db.Column(db.Integer, primary_key=True)
window_id = db.Column(db.Integer, db.ForeignKey('window.windowid'))
report_id = db.Column(db.Integer, db.ForeignKey('report.reportid'))
options = db.relationship('Option',
backref='selectedmetrics',
lazy='dynamic')
def __init__(self, window, report=None):
self.window = window
self.report = report
def __repr__(self):
return '<Selectedmetrics %r>' % self.selectedmetricsid
class Report(db.Model):
reportid = db.Column(db.Integer, primary_key=True)
scaletype = db.Column(db.Integer)
functiontype = db.Column(db.Integer)
reportname = db.Column(db.String(80))
user_id = db.Column(db.Integer, db.ForeignKey('user.userid'))
title = db.Column(db.String(80))
discription = db.Column(db.String(200))
imgs = db.relationship('Reportimg', backref='report', lazy='dynamic')
selectedmetrics = db.relationship('Selectedmetrics',
backref='report',
lazy='dynamic')
def __init__(self,
scaletype,
functiontype,
reportname,
owner,
title=None,
discription=None):
self.scaletype = scaletype
self.functiontype = functiontype
self.reportname = reportname
self.owner = owner
self.title = title
self.discription = discription
def __repr__(self):
return '<Report %r>' % self.reportname
class Trigger(db.Model):
triggerid = db.Column(db.Integer,primary_key=True,autoincrement=False)
triggername = db.Column(db.String(100))
triggervalue = db.Column(db.Float)
timeshift = db.Column(db.Integer)
triggerfunction = db.Column(db.String(64))
metricname = db.Column(db.String(80))
comparetype = db.Column(db.String(80))
calculateditem_id = db.Column(db.Integer,db.ForeignKey('calculateditem.calculateditemid'))
# action_id = db.Column(db.Integer,db.ForeignKey('action.actionid'))
actions = db.relationship('Action',backref='trigger',lazy='dynamic')
# serviceid = db.Column(db.In)
def __init__(self,triggerid,triggername,triggervalue,timeshift,calcitem,triggerfunction,metricname,comparetype):
self.triggerid = triggerid
self.triggername = triggername
self.triggervalue = triggervalue
self.timeshift = timeshift
self.calcitem = calcitem
self.triggerfunction = triggerfunction
self.metricname = metricname
self.comparetype = comparetype
def __repr__(self):
return '<Trigger %r>' % ( self.triggername )
class Reportimg(db.Model):
reportimgid = db.Column(db.Integer, primary_key=True)
reportimgname = db.Column(db.String(80))
report_id = db.Column(db.Integer, db.ForeignKey('report.reportid'))
daytime = db.Column(db.String(80))
emailschedule_id = db.Column(
db.Integer, db.ForeignKey('emailschedule.emailscheduleid'))
def __init__(self, reportimgname, daytime, report, es):
self.reportimgname = reportimgname
self.daytime = daytime
self.report = report
self.es = es
def __repr__(self):
return '<Reportimg %r>' % self.reportimgname
class Emailschedule(db.Model):
emailscheduleid = db.Column(db.Integer, primary_key=True)
frequency = db.Column(db.Integer)
starttime = db.Column(db.String(80))
subject = db.Column(db.String(80))
timezone = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.userid'))
imgs = db.relationship('Reportimg', backref='es', lazy='dynamic')
reports = db.relationship(
'Report',
secondary=email_report,
primaryjoin=(email_report.c.email_id == emailscheduleid),
secondaryjoin=(email_report.c.report_id == Report.reportid),
lazy='dynamic')
receivers = db.relationship(
'Receiver',
secondary=email_receiver,
primaryjoin=(email_receiver.c.email_id == emailscheduleid),
secondaryjoin=(email_receiver.c.receiver_id == Receiver.receiverid),
lazy='dynamic')
def __init__(self, subject, frequency, starttime, owner, timezone=0):
self.subject = subject
self.frequency = frequency
self.starttime = starttime
self.owner = owner
self.timezone = timezone
def add_report(self, report):
if not self.has_report(report):
self.reports.append(report)
return self
def rm_report(self, report):
if self.has_report(report):
self.reports.remove(report)
return self
def has_report(self, report):
return self.reports.filter_by(reportid=report.reportid).count() > 0
def add_receiver(self, receiver):
if not self.has_receiver(receiver):
self.receivers.append(receiver)
return self
def rm_receiver(self, receiver):
if self.has_receiver(receiver):
self.receivers.remove(receiver)
return self
def has_receiver(self, receiver):
return self.receivers.filter_by(
receiverid=receiver.receiverid).count() > 0
def __repr__(self):
return '<Emailschedule %r>' % self.subject
class Host(db.Model):
hostid = db.Column(db.Integer,primary_key=True,autoincrement=False,unique=True)
hostname = db.Column(db.String(80))
items = db.relationship('Item',backref='host',lazy='dynamic')
area_id = db.Column(db.Integer,db.ForeignKey('area.areaid'))
service_id = db.Column(db.Integer,db.ForeignKey('service.serviceid'))
itemtypes = db.relationship('Itemtype',
secondary=host_itemtype,
primaryjoin=(host_itemtype.c.host_id == hostid),
secondaryjoin=(host_itemtype.c.itemtype_id == Itemtype.itemtypeid),
backref=db.backref('host',lazy='dynamic'),
lazy = 'dynamic'
)
# def __init__(self,servicename):
# self.servicename = servicename
def __repr__(self):
return '<Service %r>' % self.servicename
def add_itemtype(self,itemtype):
if not self.has_itemtype(itemtype):
self.itemtypes.append(itemtype)
return self
def rm_itemtype(self,itemtype):
if self.has_itemtype(itemtype):
self.itemtypes.remove(itemtype)
return self
def has_itemtype(self,itemtype):
return self.itemtypes.filter_by(itemkey = itemtype.itemkey).count() > 0
# return self.itemtypes.filter_by(itemtypeid = itemtype.itemtypeid).count() > 0
def __init__(self,hostid,hostname,area,service):
self.hostid = hostid
self.hostname = hostname
self.area = area
self.service = service
def __repr__(self):
return '<Host %r>' % self.hostname
class Itemtype(db.Model):
itemtypeid = db.Column(db.Integer,primary_key=True)
itemtypename = db.Column(db.String(80))
itemkey = db.Column(db.String(80))
itemunit = db.Column(db.String(80))
zabbixvaluetype = db.Column(db.Integer)
items = db.relationship('Item',backref='itemtype',lazy='dynamic')
aws_id = db.Column(db.Integer,db.ForeignKey('aws.awsid'))
Itemdatatype_id = db.Column(db.Integer,db.ForeignKey('itemdatatype.itemdatatypeid'))
normalitemtype_id = db.Column(db.Integer,db.ForeignKey('normalitemtype.normalitemtypeid'))
zbxitemtype_id = db.Column(db.Integer,db.ForeignKey('zbxitemtype.zbxitemtypeid'))
time_frequency = db.Column(db.Integer)
function_type = db.Column(db.Integer)
description = db.Column(db.String(256))
bcd_type = db.Column(db.Integer)
condition = db.Column(db.String(64))
uniqueindexname = db.Column(db.String(80))
# detailitemtypes = db.relationship('Detailitemtype',backref='itemtype',lazy='dynamic')
def __init__(self, itemtypename, itemkey, uniqueindexname, aws=None, itemdatatype=None, \
itemunit=None, zabbixvaluetype=None, time_frequency=60, \
function_type=0, description=None, bcd_type=0, condition=None):
self.itemtypename = itemtypename
self.itemkey = itemkey
self.uniqueindexname = uniqueindexname
self.aws = aws
self.itemdatatype = itemdatatype
self.itemunit = itemunit
self.zabbixvaluetype = zabbixvaluetype
if aws != None:
self.time_frequency = 14400
else:
self.time_frequency = 60
self.function_type = function_type
if description is None:
description = itemtypename
self.description = description
self.bcd_type = bcd_type
self.condition = condition
def __repr__(self):
return '<Itemtype %r>' % self.itemtypename
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Chartconfig(db.Model):
chartconfigid = db.Column(db.Integer, primary_key=True)
attrs = db.relationship('Attr', backref='chartconfig', lazy='dynamic')
window_id = db.Column(db.Integer, db.ForeignKey('window.windowid'))
def __init__(self, window):
self.window = window
def __repr__(self):
return '<Chartconfig %r>' % self.chartconfigid
class Page(db.Model):
pageid = db.Column(db.Integer, primary_key=True)
pagename = db.Column(db.String(80))
windows = db.relationship('Window', backref='page', lazy='dynamic')
user_id = db.Column(db.Integer, db.ForeignKey('user.userid'))
def __init__(self, pagename, owner):
self.pagename = pagename
self.owner = owner
def __repr__(self):
return '<Page %r>' % self.pagename
class Operation(db.Model):
operationid = db.Column(db.Integer,primary_key=True)
operationname = db.Column(db.String(80))
action_id = db.Column(db.Integer,db.ForeignKey('action.actionid'))
attrs = db.relationship('Attr',backref='operation',lazy='dynamic')
def __init__(self,operationname,action):
self.operationname = operationname
self.action = action
def __repr__(self):
return '<Operation %s>' % (self.operationname)
class Action(db.Model):
actionid = db.Column(db.Integer,primary_key=True,autoincrement=False)
actionname = db.Column(db.String(80))
operations = db.relationship('Operation',backref='action',lazy='dynamic')
trigger_id = db.Column(db.Integer,db.ForeignKey('trigger.triggerid'))
def __init__(self,actionid,actionname,trigger):
self.actionid = actionid
self.actionname = actionname
self.trigger = trigger
def __repr__(self):
return '<Action %s>' % (self.actionid)
class Aws(db.Model):
awsid = db.Column(db.Integer,primary_key=True)
awsname = db.Column(db.String(80))
items = db.relationship('Item',backref='aws',lazy='dynamic')
itemtypes = db.relationship('Itemtype',backref='aws',lazy='dynamic')
area_id = db.Column(db.Integer,db.ForeignKey('area.areaid'))
def __init__(self,awsname,area):
self.awsname = awsname
self.area = area
def __repr__(self):
return '<AWS %r>' % self.awsname
class Displaytablerow(db.Model):
displaytablerowid = db.Column(db.Integer, primary_key=True)
displaytable_id = db.Column(db.Integer,
db.ForeignKey('displaytable.displaytableid'))
attrs = db.relationship('Attr', backref='displaytablerow', lazy='dynamic')
def __init__(self, displaytable):
self.displaytable = displaytable
def __repr__(self):
return '<Displaytablerow %r>' % self.displaytablerowid
class count(db.Model):
"""docstring for count"""
countid = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Integer, nullable=False)
clock = db.Column(db.BigInteger, nullable=False)
region_id = db.Column(db.Integer, db.ForeignKey("region.regionid"))
counttype_id = db.Column(db.Integer,
db.ForeignKey("counttype.counttypeid"))
def __init__(self, value, clock, region, counttype):
self.value = value
self.clock = clock
self.region = region
self.counttype = counttype
@classmethod
def get_all_month_str(cls):
result = []
for c in cls.query.order_by(count.clock).all():
month_str = clock_2_str(int(c.clock), MONTH_FORMAT)
if month_str not in result:
result.append(month_str)
return result
class Window(db.Model):
windowid = db.Column(db.Integer, primary_key=True)
windowname = db.Column(db.String(80))
type = db.Column(db.Integer)
index = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.userid'))
page_id = db.Column(db.Integer, db.ForeignKey('page.pageid'))
selectedmetrics = db.relationship('Selectedmetrics',
backref='window',
lazy='dynamic')
chartconfig = db.relationship('Chartconfig',
backref='window',
lazy='dynamic')
def __init__(self, windowname, type, index, user, page):
self.windowname = windowname
self.type = type
self.index = index
self.owner = user
self.page = page
def __repr__(self):
return '<Window %r>' % self.windowname
class Displaytable(db.Model):
displaytableid = db.Column(db.Integer, primary_key=True)
displaytablename = db.Column(db.String(80))
option_id = db.Column(db.Integer, db.ForeignKey('option.optionid'))
rows = db.relationship('Displaytablerow',
backref='displaytable',
lazy='dynamic')
def __init__(self, displaytablename, option):
self.displaytablename = displaytablename
self.option = option
def __repr__(self):
return '<Displaytable %r>' % self.displaytablename
class Option(db.Model):
optionid = db.Column(db.Integer, primary_key=True)
optionname = db.Column(db.String(80))
selectedmetrics_id = db.Column(
db.Integer, db.ForeignKey('selectedmetrics.selectedmetricsid'))
displaytables = db.relationship('Displaytable',
backref='option',
lazy='dynamic')
def __init__(self, optionname, selectedmetrics):
self.optionname = optionname
self.selectedmetrics = selectedmetrics
def __repr__(self):
return '<Option %r>' % self.optionname
class intervaldata(db.Model):
"""docstring for intervaldata"""
intervaldataid = db.Column(db.Integer, primary_key=True)
timefrom = db.Column(db.BigInteger, nullable=False)
timeto = db.Column(db.BigInteger, nullable=False)
groupname = db.Column(db.String(128), nullable=False)
itemkey = db.Column(db.String(128), nullable=False)
displayname = db.Column(db.String(128))
sumv = db.Column(db.Float)
odmonth_id = db.Column(db.Integer, db.ForeignKey("odmonth.odmonthid"))
def __init__(self, timefrom, timeto, groupname, itemkey, displayname,\
sumv, odmonth):
self.timefrom = timefrom
self.timeto = timeto
self.groupname = groupname
self.itemkey = itemkey
self.displayname = displayname
self.sumv = sumv
self.odmonth = odmonth
class billingrow(db.Model):
"""docstring for billingrow"""
billingrowid = db.Column(db.BigInteger, primary_key=True)
billingperiodstartdate = db.Column(db.BigInteger)
billingperiodenddate = db.Column(db.BigInteger)
invoicedate = db.Column(db.BigInteger)
sellerofrecord = db.Column(db.String(128))
usagetype = db.Column(db.String(128))
rateid = db.Column(db.BigInteger)
itemdescription = db.Column(db.String(256))
usagestartdate = db.Column(db.BigInteger)
usageenddate = db.Column(db.BigInteger)
usagequantity = db.Column(db.Float)
blendedrate = db.Column(db.Float)
currencycode = db.Column(db.String(64))
costbeforetax = db.Column(db.Float)
credits = db.Column(db.Float)
taxamount = db.Column(db.Float)
taxtype = db.Column(db.String(128))
totalcost = db.Column(db.Float)
invoice_id = db.Column(db.BigInteger, db.ForeignKey('invoice.invoiceid'))
apioperation_id = db.Column(db.BigInteger, \
db.ForeignKey('apioperation.apioperationid'))
payeraccount_id = db.Column(db.BigInteger, \
db.ForeignKey('payeraccount.payeraccountid'))
linkedaccount_id = db.Column(db.BigInteger, \
db.ForeignKey('linkedaccount.linkedaccountid'))
awsservice_id = db.Column(db.BigInteger, \
db.ForeignKey('awsservice.awsserviceid'))
availablezone_id = db.Column(db.BigInteger, \
db.ForeignKey('availablezone.availablezoneid'))
billingtime_id = db.Column(db.BigInteger, \
db.ForeignKey('billingtime.billingtimeid'))
def __init__(self, billingperiodstartdate,\
billingperiodenddate,\
invoicedate,\
sellerofrecord,\
usagetype,\
rateid,\
itemdescription,\
usagestartdate,\
usageenddate,\
usagequantity,\
blendedrate,\
currencycode,\
costbeforetax,\
credits,\
taxamount,\
taxtype,\
totalcost,\
tmp_invoice=None,\
tmp_apioperation=None,\
tmp_payeraccount=None,\
tmp_linkedaccount=None,\
tmp_awsservice=None,
tmp_availablezone=None,
tmp_billingtime=None):
if billingperiodstartdate is None or billingperiodenddate is None or \
invoicedate is None or itemdescription is None or usagequantity is \
None or totalcost is None:
raise Exception('Invalid input in billingrow constructor')
self.billingperiodstartdate = billingperiodstartdate
self.billingperiodenddate = billingperiodenddate
self.invoicedate = invoicedate
self.sellerofrecord = sellerofrecord
self.usagetype = usagetype
self.rateid = rateid
self.itemdescription = itemdescription
self.usagestartdate = usagestartdate
self.usageenddate = usageenddate
self.usagequantity = usagequantity
self.blendedrate = blendedrate
self.currencycode = currencycode
self.costbeforetax = costbeforetax
self.credits = credits
self.taxamount = taxamount
self.taxtype = taxtype
self.totalcost = totalcost
self.invoice = tmp_invoice
self.apioperation = tmp_apioperation
self.payeraccount = tmp_payeraccount
self.linkedaccount = tmp_linkedaccount
self.awsservice = tmp_awsservice
self.availablezone = tmp_availablezone
self.billingtime = tmp_billingtime
@classmethod
def get_billstart_month(cls):
result = []
for x in cls.query.group_by(billingrow.billingperiodstartdate).all():
clock = x.billingperiodstartdate
time_str = clock_2_str(clock, TO_TIME_FORMAT)
if time_str is not None:
result.append(time_str)
return result
def __repr__(self):
return "<Itemdatatype %r>" % self.itemdatatypename
# class Detailitemtype(db.Model):
# detailitemtypeid = db.Column(db.Integer,primary_key=True)
# detailitemtypename = db.Column(db.String(80),unique=True)
# items = db.relationship('Item',backref='Detailitemtype',lazy='dynamic')
# itemtype_id = db.Column(db.Integer,db.ForeignKey('itemtype.itemtypeid'))
# aws_id = db.Column(db.Integer,db.ForeignKey('aws.awsid'))
# def __repr__(self):
# return '<Detailitemtype %r>' % self.detailitemtypename
service_itemtype = db.Table('service_itemtype',
db.Column('service_id',db.Integer,db.ForeignKey('service.serviceid')),
db.Column('itemtype_id',db.Integer,db.ForeignKey('itemtype.itemtypeid')))
class Service(db.Model):
serviceid = db.Column(db.Integer,primary_key=True,autoincrement=True)
servicename = db.Column(db.String(80),unique=True)
hosts = db.relationship('Host',backref='service',lazy='dynamic')
items = db.relationship('Item',backref='service',lazy='dynamic')
itemtypes = db.relationship('Itemtype',
secondary=service_itemtype,
primaryjoin=(service_itemtype.c.service_id == serviceid),
secondaryjoin=(service_itemtype.c.itemtype_id == Itemtype.itemtypeid),
backref=db.backref('service',lazy='dynamic'),
lazy = 'dynamic'
)
class Item(db.Model):
itemid = db.Column(db.Integer,primary_key=True,autoincrement=False,unique=True)
itemname = db.Column(db.String(80))
host_id = db.Column(db.Integer,db.ForeignKey('host.hostid'))
itemtype_id = db.Column(db.Integer,db.ForeignKey('itemtype.itemtypeid'),nullable=False)
# detailitemtype_id = db.Column(db.Integer,db.ForeignKey('detailitemtype.detailitemtypeid'))
area_id = db.Column(db.Integer,db.ForeignKey('area.areaid'))
service_id = db.Column(db.Integer,db.ForeignKey('service.serviceid'))
aws_id = db.Column(db.Integer,db.ForeignKey('aws.awsid'))
def __init__(self,itemid,itemname,host=None,itemtype=None):
self.itemid = itemid
self.itemname = itemname
self.host = host
self.itemtype = itemtype
area = None
service = None
aws = None
if host != None:
area = host.area
service = host.service
if itemtype != None:
aws = itemtype.aws
self.area = area
self.service = service
self.aws = aws
def set_belong_to_area(self,area):
if self.area == area:
return None
self.area = area
return self
def __repr__(self):
return '<Item %r>' % self.itemname
def get_host_ip(self):
assert self.host is not None, 'current item: %s does not ' + \
'belong to any host' % (self)
assert self.host.hostid is not None
ip = 'unkown'
session = loadSession()
zi = session.query(Zabbixinterface).\
filter_by(hostid=self.host.hostid).first()
session.close()
if zi != None:
ip = zi.ip
return ip
def get_available_status(self):
assert self.host is not None, 'current item: %s does not ' + \
'belong to any host' % (self)
assert self.host.hostid is not None
available_status = None
session = loadSession()
zh = session.query(Zabbixhosts).get(self.host.hostid)
session.close()
if zh != None:
available_status = zh.available
return available_status
pagename = db.Column(db.String(80))
windows = db.relationship('Window', backref='page', lazy='dynamic')
user_id = db.Column(db.Integer, db.ForeignKey('user.userid'))
def __init__(self, pagename, owner):
self.pagename = pagename
self.owner = owner
def __repr__(self):
return '<Page %r>' % self.pagename
email_report = db.Table(
'email_report',
db.Column('email_id', db.Integer,
db.ForeignKey('emailschedule.emailscheduleid')),
db.Column('report_id', db.Integer, db.ForeignKey('report.reportid')))
class Receiver(db.Model):
receiverid = db.Column(db.Integer, primary_key=True)
mailaddress = db.Column(db.String(80))
def __init__(self, mailaddress):
self.mailaddress = mailaddress
def __repr__(self):
return '<Receiver %r>' % self.mailaddress
email_receiver = db.Table(
