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 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'
)
# 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):
# print 'itemtypeid',itemtype.itemtypeid
# print self.itemtypes.filter_by(itemtypeid = itemtype.itemtypeid).count()
return self.itemtypes.filter_by(itemkey = itemtype.itemkey).count() > 0
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 Area(db.Model):
areaid = db.Column(db.Integer,primary_key=True,autoincrement=True)
areaname = db.Column(db.String(80),unique=True)
hosts = db.relationship('Host',backref='area',lazy='dynamic')
items = db.relationship('Item',backref='area',lazy='dynamic')
awses = db.relationship('Aws',backref='area',lazy='dynamic')
services = db.relationship('Service',
secondary=area_service,
primaryjoin=(area_service.c.area_id == areaid),
secondaryjoin=(area_service.c.service_id == Service.serviceid),
backref=db.backref('area',lazy='dynamic'),
lazy = 'dynamic'
)
itemtypes = db.relationship('Itemtype',
secondary=area_itemtype,
primaryjoin=(area_itemtype.c.area_id == areaid),
secondaryjoin=(area_itemtype.c.itemtype_id == Itemtype.itemtypeid),
backref=db.backref('area',lazy='dynamic'),
lazy = 'dynamic'
)
# def __init__(self,areaname):
# self.areaname = areaname
def __repr__(self):
return '<Area %r>' % self.areaname
def add_service(self,service):
if not self.has_service(service):
self.services.append(service)
return self
def rm_service(self,service):
if self.has_service(service):
self.services.remove(service)
return self
def has_service(self,service):
return self.services.filter_by(serviceid = service.serviceid).count() > 0
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
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 User(db.Model):
userid = db.Column(db.Integer, primary_key=True, autoincrement=False)
username = db.Column(db.String(80), unique=True)
# pw_hash = db.Column(db.String(200))
role = db.Column(db.Integer)
# loginpermission = db.Column(db.Integer)
email = db.Column(db.String(120))
windows = db.relationship('Window', backref='owner', lazy='dynamic')
pages = db.relationship('Page', backref='owner', lazy='dynamic')
reports = db.relationship('Report', backref='owner', lazy='dynamic')
schedules = db.relationship('Emailschedule',
backref='owner',
lazy='dynamic')
def __init__(self, userid, username, role, email):
self.userid = userid
self.username = username
# self.set_password(password)
self.role = role
# self.loginpermission = loginpermission
self.email = email
def is_authenticated(self):
return True
def is_admin(self):
return int(self.role) <= 1
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.userid) # python 2
except NameError:
return str(self.userid) # python 3
# def set_password(self, password):
# self.pw_hash = generate_password_hash(password)
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
def __repr__(self):
return '<User %r>' % self.username
class billingtime(db.Model):
"""docstring for bllingtime"""
billingtimeid = db.Column(db.BigInteger, primary_key=True)
billingperiodstartdate = db.Column(db.BigInteger)
billingperiodenddate = db.Column(db.BigInteger)
billingrows = db.relationship('billingrow', backref='billingtime', lazy=\
'dynamic')
def __init__(self, start_date, end_date):
if start_date is None or end_date is None:
raise Exception('Invalid input in billingtime constructor')
self.billingperiodstartdate = start_date
self.billingperiodenddate = end_date
@classmethod
def get_all_timestr(cls):
result = []
for bt in billingtime.query.order_by(cls.billingperiodstartdate.desc())\
.all():
if bt.billingrows.count() > 0:
clock = bt.billingperiodstartdate
time_str = clock_2_str(clock, TO_TIME_FORMAT)
if time_str is not None:
result.append(time_str)
return result
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 payeraccount(db.Model):
"""docstring for payeraccount"""
payeraccountid = db.Column(db.BigInteger, primary_key=True, \
autoincrement=False)
payeraccountname = db.Column(db.String(128))
payerponumber = db.Column(db.BigInteger)
billingrows = db.relationship('billingrow', backref='payeraccount', \
lazy='dynamic')
def __init__(self, payeraccountid, payeraccountname, payerponumber):
if payeraccountid is None or payeraccountname is None:
raise Exception('Invalid input in payeraccount constructor')
self.payeraccountid = payeraccountid
self.payeraccountname = payeraccountname
self.payerponumber = payerponumber
def fee_of_time(self, clock, tmp_linkedaccount=None):
if clock is None:
raise Exception('Invalid input in payeraccount.fee_of_time')
tmp_arr = db.session.query(db.func.sum(billingrow.totalcost)\
.label('total')).filter_by(payeraccount=self,\
linkedaccount=tmp_linkedaccount, billingperiodstartdate=clock).all()
return tmp_arr[0][0] if len(tmp_arr) > 0 else 0
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 counttype(db.Model):
"""docstring for counttype """
counttypeid = db.Column(db.Integer, primary_key=True)
counttypename = db.Column(db.String(128), nullable=False)
counts = db.relationship("count", backref="counttype", \
lazy="dynamic")
def __init__(self, counttypename):
self.counttypename = counttypename
class region(db.Model):
"""docstring for region"""
regionid = db.Column(db.Integer, primary_key=True)
regionshort = db.Column(db.String(128), nullable=False)
regionlong = db.Column(db.String(128), nullable=False)
counts = db.relationship("count", backref="region", \
lazy="dynamic")
def __init__(self, regionshort, regionlong):
self.regionshort = regionshort
self.regionlong = regionlong
class Itemdatatype(db.Model):
itemdatatypeid = db.Column(db.Integer,primary_key=True)
itemdatatypename = db.Column(db.String(80),unique=True)
itemtypes = db.relationship('Itemtype',backref='itemdatatype',lazy='dynamic')
def __init__(self,itemdatatypename):
self.itemdatatypename = itemdatatypename
def __repr__(self):
return "<Itemdatatype %r>" % self.itemdatatypename
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 Calculateditem(db.Model):
calculateditemid = db.Column(db.Integer,primary_key=True,autoincrement=False)
formula = db.Column(db.String(512))
triggers = db.relationship('Trigger',backref='calcitem',lazy='dynamic')
def __init__(self,calculateditemid,formula):
self.calculateditemid = calculateditemid
self.formula = formula
def __repr__(self):
return '<Calculateditem %r>' % (self.formula)
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 User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class invoice(db.Model):
"""docstring for invoice"""
invoiceid = db.Column(db.BigInteger, primary_key=True, \
autoincrement=False)
billingrows = db.relationship('billingrow', backref='invoice', \
lazy='dynamic')
def __init__(self, invoiceid):
if invoiceid is None:
raise Exception('Invalid input in invoice constructor')
self.invoiceid = invoiceid
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 apioperation(db.Model):
"""docstring for apioperation"""
apioperationid = db.Column(db.BigInteger, primary_key=True)
apioperationname = db.Column(db.String(128))
billingrows = db.relationship('billingrow', backref='apioperation', \
lazy='dynamic')
def __init__(self, apioperationname):
if apioperationname is None:
raise Exception('Invalid input in apioperation constructor')
self.apioperationname = apioperationname
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 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 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 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 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 Normalitemtype(db.Model):
normalitemtypeid = db.Column(db.Integer,primary_key=True)
itemtypes = db.relationship('Itemtype',backref='nit',lazy='dynamic')
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
class odmonth(db.Model):
"""docstring for odmonth"""
odmonthid = db.Column(db.Integer, primary_key=True)
beginclock = db.Column(db.Integer, unique=True)
intervaldatas = db.relationship("intervaldata", backref="odmonth", \
lazy="dynamic")
def __init__(self, beginclock):
self.beginclock = beginclock
@classmethod
def get_all_timestr(cls):
result = []
for bt in cls.query.order_by(cls.beginclock.desc())\
.all():
clock = bt.beginclock
time_str = clock_2_str(clock, MONTH_FORMAT)
if time_str is not None:
result.append(time_str)
return result
def gen_table_content(self):
result = {}
index_date_map = []
index = 0
for itvd in self.intervaldatas.order_by(intervaldata.timefrom).all():
date = clock_2_str(itvd.timefrom, DATE_FORMAT)
if not result.has_key(date):
result[date] = {}
index_date_map.append(date)
result[date][itvd.displayname] = itvd.sumv
order_result = []
for di in xrange(len(index_date_map)):
tmp = {
"date": index_date_map[di],
"data": result[index_date_map[di]]
}
order_result.append(tmp)
return order_result
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 linkedaccount(db.Model):
"""docstring for linkedaccount"""
linkedaccountid = db.Column(db.BigInteger, primary_key=True, \
autoincrement=False)
linkedaccountname = db.Column(db.String(128))
taxationaddress = db.Column(db.String(256))
billingrows = db.relationship('billingrow', backref='linkedaccount', \
lazy='dynamic')
def __init__(self, linkedaccountid, linkedaccountname, taxationaddress):
if linkedaccountid is None or linkedaccountname is None:
raise Exception('Invalid input in linkedaccount constructor')
self.linkedaccountid = linkedaccountid
self.linkedaccountname = linkedaccountname
self.taxationaddress = taxationaddress
def fee_of_time(self, clock):
if clock is None:
raise Exception('Invalid input in "linkedaccount.fee_of_time"')
tmp_arr = db.session.query(db.func.sum(billingrow.totalcost)\
.label('total')).filter_by(\
linkedaccount=self, billingperiodstartdate=clock).all()
return tmp_arr[0][0] if len(tmp_arr) > 0 else 0
def build_list(self,clock):
if clock is None:
raise Exception('Invalid input in "linkedaccount.build_list"')
result = {}
result['Total'] = self.fee_of_time(clock)
result['by_services'] = {}
for s in awsservice.query.all():
tmp_r = s.build_list(clock, self)
if len(tmp_r['region_info']) > 0:
result['by_services'][s.productname] = tmp_r
return result
