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