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 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 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 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 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 CheckedWebsite(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
website_url = db.Column(db.String(80), unique=False, nullable=True)
response_code = db.Column(db.String(10), unique=False, nullable=True)
response_message = db.Column(db.String(10), unique=False, nullable=True)
isdown = db.Column(db.Boolean)
def __repr__(self):
return '{} {} {} {} {}'.format(self.check_date, self.website_url,
self.response_code,
self.response_message, self.isdown)
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 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 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 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 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 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
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 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 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 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
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 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 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 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 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 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 User(db.Model, UserMixin):
__table_args__ = {'extend_existing': True}
# Basic Account Model
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(20), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
account_creation_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
password_reset_count = db.Column(db.Integer, nullable=False, default=0)
last_password_reset = db.Column(db.DateTime, nullable=True)
last_login = db.Column(db.DateTime, nullable=True)
login_count = db.Column(db.Integer, nullable=False, default=0)
last_ip = db.Column(db.String, nullable=True)
isStaff = db.Column(db.Boolean, nullable=False, default=False)
isPayingUser = db.Column(db.Boolean, nullable=False, default=False)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', {self.email}', {self.image_file}')"
class ContiniousMonitoring(db.Model):
__table_args__ = {'extend_existing': True}
# DB Metadata problem FIX
# db.metadata.clear()
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer
) #New Database - user_id = db.Column(db.Integer, db.ForeginKey('User.id'))
creation_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
website_name = db.Column(db.String(20), unique=True, nullable=False)
website_url = db.Column(db.String(20), nullable=False)
isRunning = db.Column(db.Boolean)
response_time = db.Column(db.String, nullable=False)
up_time = db.Column(db.String, nullable=False)
def __repr__(self):
return '{} {} {} {} {}'.format(self.website_name, self.website_url,
self.isRunning, self.response_time,
self.up_time)
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(20), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', {self.email}', {self.image_file}')"
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 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 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
