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