def execute(self):
if self.old_var.text().strip():
old_column = Column.get_by_name(self.old_var.text().strip())
new_column = None
if self.same.isChecked():
new_column = Column.get_by_name(self.new_var.text().strip())
recode = Recode(old_column, new_column)
recode.execute()
def addColumnView(request, boardId=None):
if request.method == 'GET' and boardId is not None: # se il metodo e una GET e il board id non e di proprieta del user ritorna un notfound
board = Board.objects.filter(pk=boardId, users=request.user)
if not board.exists():
return HttpResponseNotFound(NOT_FOUND_PAGE)
form = AddColumnForm(initial={
'boardId': boardId,
'name': ''
}) # preinserimento del board id nel form in un campo hidden
elif request.method == 'POST': # se la richista e una post e il form e valido crea una nuova colonna
user = User.objects.get(username=request.user.username)
form = AddColumnForm(request.POST)
form.setUser(user)
if form.is_valid():
columnName = form.cleaned_data.get('columnname')
boardId = form.cleaned_data.get('boardId')
board = Board.objects.filter(users=request.user)
newcolumn = Column(name=columnName, board=board.get(pk=boardId))
newcolumn.save()
return redirect(board.get(pk=boardId).get_absolute_url())
elif '*not_found' in str(
form.errors
): # se tra gli errori del form e presente un not_found error restituisce la rispettiva pagina
return HttpResponseNotFound(NOT_FOUND_PAGE)
else:
boardId = form.cleaned_data.get('boardId')
else:
return HttpResponseNotFound(NOT_FOUND_PAGE)
return render(request, 'addcolumn.html', {
'form': form,
'board': Board.objects.get(pk=boardId)
})
class Update_change(Node_Base):
__tablename__ = 'update_change'
id = Column(db.Integer,primary_key=True, autoincrement=True)
update_id=Column(db.String(255), db.ForeignKey('updates.update_id'))
change_id= Column(db.String(255), db.ForeignKey('changes.change_id'))
def __repr__(self):
return "<Update_change(update_id='%s',change_id='%s')>" %(self.update_id,self.change_id)
class Groupalert(Node_Base):
__tablename__ = 'groupalerts'
group_id=Column(db.Integer,primary_key=True,autoincrement=True)
group_name=Column(db.String(255))
group_desc=Column(db.Text)
def __repr__(self):
return "<Groupalert(group_id='%s',group_name='%s',group_desc='%s')>" %(self.group_id,self.group_name,self.group_desc)
class Threshold_list(Node_Base):
__tablename__ = 'threshold_lists'
id=Column(db.Integer,primary_key=True,autoincrement=True)
description=Column(db.String(255))
thresholdobjects=relationship("Thresholdobject", back_populates="threshold_list")
polldatatemplate=relationship("Polldatatemplate", back_populates="threshold_list")
polleddatas=relationship("Polleddata", back_populates="threshold_list")
def __repr__(self):
return "<Threshold_list(id='%s',description='%s')>" %(self.id,self.description)
class Service_info_File_config(Node_Base):
__tablename__ = 'service_info_file_config'
id = Column(db.Integer, primary_key=True, autoincrement=True)
service_id = Column(db.Integer, db.ForeignKey('service_infos.service_id'))
file_config_id = Column(db.Integer, db.ForeignKey('file_configs.file_id'))
def __repr__(self):
return "<Service_info_File_config(service_id='%s',file_config_id='%s')>" % (
self.service_id, self.file_config_id)
class User(Base):
__tablename__ = 'users'
id = Column(SmallInteger, primary_key=True, autoincrement=True)
name = Column(String(255))
trades = relationship("Trade", back_populates="user")
transactions: [] = relationship("Transaction", back_populates="user")
follows: [] = relationship("Follow", back_populates="follower")
def __init__(self, name):
self.name = name
class Node_role(Node_Base):
__tablename__ = 'node_roles'
id = Column(db.Integer, primary_key=True, autoincrement=True)
role_name = Column(db.String(255))
node_id = Column(db.Integer, db.ForeignKey('nodes.node_id'))
node = relationship("Node")
def __repr__(self):
return "<Node_role(role_name='%s',node_id='%s')>" % (self.role_name,
self.node_id)
class Protocoldetail(Node_Base):
__tablename__ = 'protocoldetails'
protocolid = Column(db.Integer, primary_key=True, autoincrement=True)
protocolname = Column(db.String(255))
metricdetails = relationship("Metricdetail",
back_populates="protocoldetail")
def __repr__(self):
return "<Protocoldetail(protocolid='%s',protocolname='%s')>" % (
self.protocolid, self.protocolname)
class Update(Node_Base):
__tablename__ = 'updates'
update_id = Column(db.String(255),primary_key=True,default=generate_uuid)
created_at=Column(db.DateTime)
deleted_at= Column(db.DateTime)
note=Column(db.Text)
log=Column(db.Text)
change=relationship('Update',secondary='update_change')
def __repr__(self):
return "<Update(update_id='%s',created_at='%s',deleted_at='%s',note='%s',log='%s')>" %(self.update_id,self.created_at,self.deleted_at,self.note,self.log)
class Groupdevicesdevicedetail(Node_Base):
__tablename__ = 'groupdevicesdevicedetails'
id = Column(db.Integer, primary_key=True, autoincrement=True)
devicedetail_did = Column(db.Integer, db.ForeignKey('devicedetails.did'))
groupdevice_id = Column(db.Integer, db.ForeignKey('groupdevices.group_id'))
devicedetail = relationship("Devicedetail")
groupdevice = relationship("Groupdevice")
def __repr__(self):
return "<Groupdevicesdevicedetail(id='%s',devicedetail_did='%s',groupdevice_id='%s')>" % (
self.id, self.devicedetail_did, self.groupdevice_id)
class Comment(Base):
id = Column(Integer, index=True, primary_key=True)
author = Column(String(30), comment="昵称")
content = Column(Text, comment="评论内容")
post_id = Column(Integer, ForeignKey('post.id'))
post = relationship('Post', back_populates='comments')
replied_id = Column(Integer, ForeignKey('comment.id'))
replied = relationship('Comment', back_populates='replies', remote_side=[id])
replies = relationship('Comment', back_populates='replied', cascade='all, delete-orphan')
class Groupevicepolledatatemplate(Node_Base):
__tablename__ = 'groupdevicepolledatatemplate'
id=Column(db.Integer,primary_key=True,autoincrement=True)
groupdevices_group_id=Column(db.Integer , db.ForeignKey('groupdevices.group_id'))
polldatatemplate_id=Column(db.Integer , db.ForeignKey('polldatatemplate.id'))
#
groupdevice=relationship("Groupdevice")
polldatatemplate=relationship("Polldatatemplate")
def __repr__(self):
return "<Groupevicepolledatatemplate(id='%s',groupdevices_group_id='%s',polldatatemplate_id='%s',groupdevice='%s',polldatatemplate='%s')>" %(self.id,self.groupdevices_group_id,self.polldatatemplate_id, self.groupdevice, self.polldatatemplate)
class Groupdevice(Node_Base):
__tablename__ = 'groupdevices'
group_id=Column(db.Integer,primary_key=True,autoincrement=True)
group_name=Column(db.String(255))
group_desc=Column(db.Text)
is_manual=Column(db.Integer)
#
groupdevicesdevicedetails=relationship("Groupdevicesdevicedetail", back_populates="groupdevice")
polleddatas=relationship("Polleddata", back_populates="groupdevice")
groupdevicepolledatatemplates=relationship("Groupevicepolledatatemplate", back_populates="groupdevice")
def __repr__(self):
return "<Groupdevice(group_id='%s',group_name='%s',group_desc='%s',is_manual='%s')>" %(self.group_id,self.group_name,self.group_desc,self.is_manual)
def create_column(obj): ''' ''' c = Column(content_object=obj) key = '' while True: key = generate_sha1()[:20] if not Column.objects.filter(secret_id=key).count(): break c.secret_id = key c.save()
def create_column(obj):
'''
'''
c = Column(content_object=obj)
key = ''
while True:
key = generate_sha1()[:20]
if not Column.objects.filter(secret_id=key).count():
break
c.secret_id = key
c.save()
class Service_info(Node_Base):
__tablename__ = 'service_infos'
service_id = Column(db.Integer, primary_key=True, autoincrement=True)
service_type = Column(db.String(255))
service_status = Column(db.String(255))
tag = Column(db.String(255))
node_id = Column(db.Integer, db.ForeignKey('nodes.node_id'))
node = relationship("Node")
file_configs = relationship("File_config",
secondary='service_info_file_config')
def __repr__(self):
return "<Service_info(service_id='%s',service_type='%s',service_status='%s',tag='%s',node_id='%s')>" % (
self.service_id, self.service_type, self.service_status, self.tag,
self.node_id)
def to_records(cls):
columns = Column.count()
rows = Row.count()
return [[str(Cell.array[(row, column)]._data)
if (row, column) in Cell.array else ""
for column in range(columns)] for row in range(rows)]
class Deployment(Node_Base):
__tablename__ = 'deployments'
deployment_id = Column(db.Integer,primary_key=True, autoincrement=True)
created_at=Column(db.DateTime)
updated_at= Column(db.DateTime)
finished_at=Column(db.DateTime)
status=Column(db.String(255))
name=Column(db.String(255))
jsondata=Column(db.Text)
log=Column(db.Text)
result=Column(db.String(255))
progress=Column(db.String(255))
service_setups = relationship("Service_setup", back_populates="deployment")
node=relationship("Node", uselist=False, back_populates="deployment")
def __repr__(self):
return "<Deployment(deployment_id='%s',created_at='%s',updated_at='%s',finished_at='%s',status='%s',name='%s',jsondata='%s',log='%s',result='%s',progress='%s')>" %(self.deployment_id,self.created_at,self.updated_at,self.finished_at,self.status,self.name,self.jsondata,self.log,self.result,self.progress)
def headerData(self, id, orientation, role=None):
if orientation == Qt.Horizontal:
if role == Qt.ItemDataRole:
return str(id)
elif role == Qt.DisplayRole:
column = Column.get(id)
return column.name if column else "var"
elif role == Qt.SizeHintRole:
return CellModel.ColumnSize
else:
if role == Qt.ItemDataRole:
return str(id)
elif role == Qt.DisplayRole:
return str(id + 1)
elif role == Qt.TextAlignmentRole:
return Qt.AlignCenter
elif role == Qt.SizeHintRole:
return CellModel.RowSize
elif role == Qt.BackgroundRole:
if Selection().is_selected(id):
return CellModel.SelectedRowColor
else:
return CellModel.UnSelectedRowColor
class Admin(Base):
id = Column(Integer, primary_key=True, index=True)
username = Column(String(20), comment="账号")
password_hash = Column(String(128), comment="密码")
blog_title = Column(String(60), comment="博客标题")
blog_sub_title = Column(String(100), comment="博客子标题")
name = Column(String(30), comment="作者名称")
about = Column(Text, comment="关于")
def main():
# RUN FROM COMMAND LINE: python -c 'from builder import *; main()'
monthly_xco2 = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200]
monthly_uncertainty = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
xco2 = XCo2(monthly_xco2, monthly_uncertainty)
column = Column(id(), 43.65, -79.38, xco2)
neighbouringColumns = [column, column]
place = generatePlace("Toronto", "Ontario", "CA", 43.65, -79.38, column, neighbouringColumns)
generateJson([place])
class Polleddata(Node_Base):
__tablename__ = 'polleddata'
id=Column(db.Integer,primary_key=True,autoincrement=True)
name=Column(db.String(255))
agent=Column(db.String(255))
period=Column(db.Integer)
active=Column(db.Integer)
threshold_activate=Column(db.Integer)
devicedetails_did=Column(db.Integer , db.ForeignKey('devicedetails.did'))
groupdevices_group_id=Column(db.Integer , db.ForeignKey('groupdevices.group_id'))
threshold_lists_id=Column(db.Integer , db.ForeignKey('threshold_lists.id'))
metricdetails_metricid=Column(db.Integer , db.ForeignKey('metricdetails.metricid'))
devicedetail=relationship("Devicedetail")
metricdetail=relationship("Metricdetail")
threshold_list=relationship("Threshold_list")
groupdevice=relationship("Groupdevice")
def __repr__(self):
return "<Polleddata(id='%s',name='%s',agent='%s',period='%s',active='%s',threshold_activate='%s',devicedetails_did='%s',groupdevices_group_id='%s',threshold_lists_id='%s',metricdetails_metricid='%s')>" %(self.id,self.name,self.agent,self.period,self.active,self.threshold_activate,self.devicedetails_did,self.groupdevices_group_id,self.threshold_lists_id,self.metricdetails_metricid)
def select(self):
if self.query.select:
select = deepcopy(self.query.select)
for item in self.query.select_scanner.data:
col, reg = item['col'], item['re']
if reg:
select = re.sub('(?:%s)' % Column.get(col).name,
'd{}'.format(col), select)
return models.Query.ComputeSelect.format(select=select)
else:
return models.Query.Select
def where(self):
if self.query.input:
where = deepcopy(self.query.input)
for item in self.query.scanner.data:
col, reg = item['col'], item['re']
if reg:
where = re.sub('(?:%s)' % Column.get(col).name,
'd{}'.format(col), where)
return models.Query.Where.format(where=where)
else:
return ""
def data(self, index, role=None):
row, col = index.row(), index.column()
if role == Qt.DisplayRole:
column = Column.get(row)
if column:
return ColumnListModel.item_data[col](column)
else:
logger.debug("Column not found. column_id={}".format(row))
if role == Qt.SizeHintRole:
return QtCore.QSize(ColumnListModel.item_size[col], 15)
if role == Qt.TextAlignmentRole:
return ColumnListModel.item_alignment[col]
def post(self, website_id):
_args = request.json
_name = _args.get('name', None)
if not _name or len(_name) > 20:
return {'status': 400, 'message': '请提供正确的栏目名称'}, 400
_layer = int(_args.get('layer', 1))
if not _layer:
return {'status': 400, 'message': '请提供正确的栏目层级'}, 400
_parent = _args.get('parent', None)
_p_col = None
if _layer > 1 and not _parent:
return {'status': 400, 'message': '请提供正确的父级栏目名称'}, 400
if _layer > 1 and _parent:
_p_col = Column.query.filter_by(name=_parent).first()
if not _p_col:
return {'status': 400, 'message': '找不到对应的父级栏目'}, 400
_description = _args.get('description', None)
_column = Column(name=_name, layer=_layer, parent=_parent, description=_description, website_id=website_id)
db.session.add(_column)
db.session.commit()
return _column.to_dict(), 200
def json2schema(schema_json, commit = True, destdb = None):
"""
Creates Database, Table, and Column objects as needed to satisfy the incoming schema.
If the table is already present, assume we are updating: delete all columns and recreate from the schema.
Unless commit is false, call the required sql to create the incoming tables in the destination database.
"""
schema = json.loads(schema_json)
for dbname, table_schema in schema.iteritems():
if destdb:
dbname = destdb
try:
db = Database.objects.get(name=dbname)
except Database.DoesNotExist:
db = Database(name=dbname)
db.save()
for tablename, column_schema in table_schema.iteritems():
try:
table = Table.objects.get(db=db, name=tablename)
for column in Column.objects.filter(table=table):
column.delete()
except Table.DoesNotExist:
table = Table(db=db, name=tablename)
table.save()
for columnname, columntype in column_schema.iteritems():
column = Column(table=table, name=columnname, type=columntype)
column.save()
if commit:
model = ModelGenerator.getModel(dbname, tablename)
cursor = connections[dbname].cursor()
for sql in ModelGenerator.getSQL(model):
cursor.execute(sql)
return None
def execute(self):
query = Query(select=self.input.toPlainText())
query.execute()
if query.error == Query.NoError:
var_name = self.target.text().strip()
column = None
new_column = False
if var_name:
logger.debug("var_name={}".format(var_name))
column = Column.get_by_name(var_name)
if not column:
column = Column(Column.count(), name=var_name)
new_column = True
logger.debug("new_column={}".format(new_column))
for row, data in query.result.items():
if new_column:
Cell(row, column.id, data=data)
else:
cell = Cell.get(row, column.id)
cell.data = data
def scan(self, input):
logger.debug('scanning query. query={}'.format(self.query))
for col in Column.array:
self.data.append({
'col': col,
're': re.search('(?:%s)' % Column.get(col).name,
input)})
cols = [item['col'] for item in self.data if item['re']]
for column in cols:
logger.debug(column)
if not cols:
self.query.error = models.Query.NoColumnError
self.query.status = models.Query.Scanned
self._cols = cols
class Polldatatemplate(Node_Base):
__tablename__ = 'polldatatemplate'
id = Column(db.Integer, primary_key=True, autoincrement=True)
name = Column(db.String(255))
agent = Column(db.String(255))
period = Column(db.Integer)
active = Column(db.Integer)
oid = Column(db.String(255))
threshold_activate = Column(db.Integer)
protocol = Column(db.String(255))
metricdetail_id = Column(db.Integer,
db.ForeignKey('metricdetails.metricid'))
threshold_list_id = Column(db.Integer, db.ForeignKey('threshold_lists.id'))
#
metricdetail = relationship("Metricdetail")
threshold_list = relationship("Threshold_list")
def __repr__(self):
return "<Polldatatemplate(id='%s',name='%s',agent='%s',period='%s',active='%s',oid='%s',threshold_activate='%s',protocol='%s',metricdetail_id='%s',threshold_list_id='%s')>" % (
self.id, self.name, self.agent, self.period, self.active, self.oid,
self.threshold_activate, self.protocol, self.metricdetail_id,
self.threshold_list_id)
def columnCount(self, index=None, *args, **kwargs):
columns_count = Column.count()
# logger.debug("columns_count={}, CellModel.Columns={}"
# .format(columns_count, CellModel.Columns))
# if CellModel.Columns - COL_OFFSET <= columns_count:
# logger.debug("CellModel.Columns changed.")
# CellModel.Columns = columns_count + COL_OFFSET
# logger.debug("index.row={}, index.col={}".format(index.row(),
# index.column()))
# self.columnChange()
# CellModel.Columns += 1
return CellModel.Columns
def __init__(self, parent):
super(ColChange, self).__init__(parent)
self.column = Column.get(0)
self.general_attributes = ColGeneralAttributes(self)
self.values = ColValues(self)
self.missing = ColMissing(self)
self.vbox = QtWidgets.QVBoxLayout(self)
# self.vbox.setContentsMargins(0, 0, 0, 0)
self.vbox.addWidget(self.general_attributes, QtCore.Qt.AlignTop)
self.vbox.addWidget(self.values, QtCore.Qt.AlignTop)
self.vbox.addWidget(self.missing, QtCore.Qt.AlignTop)
# self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.set(self.column)
ColChange.instance = self
class Post(Base):
id = Column(Integer, index=True, primary_key=True)
title = Column(String(100), comment="文章标题")
body = Column(Text, comment="文章内容")
# 文章状态
status = Column(Integer, default=1, comment="文章状态,1 置顶显示 2正常显示 3 不显示")
reading = Column(Integer, default=0, comment="阅读量")
category_id = Column(Integer, ForeignKey('category.id'))
# category = relationship('Category', back_populates='post')
category = relationship('Category', back_populates='posts')
# 级联操作
comments = relationship('Comment', back_populates='post', cascade='all')
class Devicedetail(Node_Base):
__tablename__ = 'devicedetails'
did = Column(db.Integer, primary_key=True, autoincrement=True)
mode = Column(db.String(255), default="")
status = Column(db.Text)
errorstring = Column(db.String(255))
timeinterval = Column(db.String(255))
last_updated_on = Column(db.DateTime)
isprofilebased = Column(db.Integer)
fetch_rules = Column(db.Integer)
ip = Column(db.String(255))
polleddatas = relationship("Polleddata", back_populates="devicedetail")
groupdevicesdevicedetails = relationship("Groupdevicesdevicedetail",
uselist=False,
back_populates="devicedetail")
alerts = relationship("Alert", back_populates="devicedetail")
def __repr__(self):
return "<Devicedetail(did='%s',mode='%s',status='%s',errorstring='%s',timeinterval='%s',last_updated_on='%s',isprofilebased='%s',fetch_rules='%s',ip='%s')>" % (
self.did, self.mode, self.status, self.errorstring,
self.timeinterval, self.last_updated_on, self.isprofilebased,
self.fetch_rules, self.ip)
def data(self, index, role=None):
# logger.debug("index={}, role={}".format(QModelIndex, role))
row, column = index.row(), index.column()
if role == Qt.DisplayRole:
cell = Cell.get(row, column)
return cell.data if cell else None
if role == Qt.EditRole:
cell = Cell.get(row, column)
return str(cell.data) if cell else None
if role == Qt.SizeHintRole:
return CellModel.CellSize
if role == Qt.TextAlignmentRole:
column = Column.get(column)
if column:
if column.type.type == DataType.Numeric:
return CellModel.NumericCellAlign
class Password(Node_Base):
__tablename__ = 'passwords'
password_id = Column(db.String(255),
primary_key=True,
default=generate_uuid)
created_at = Column(db.DateTime)
updated_at = Column(db.DateTime)
user = Column(db.String(255))
password = Column(db.String(255))
update_id = Column(db.String(255), db.ForeignKey('updates.update_id'))
service_name = Column(db.String(255))
update = relationship("Update")
def __repr__(self):
return "<Password(password_id='%s',created_at='%s',updated_at='%s',user='******',password='******',update_id='%s',service_name='%s')>" % (
self.password_id, self.created_at, self.updated_at, self.user,
self.password, self.update_id, self.service_name)
def __init__(self, row, column, data=None):
self.id = len(Cell.array)
self.row_id = row
self.column_id = column
self._data = data
column_obj = Column.get(column)
row_obj = Row.get(row)
if not self.column:
self.column = Column(column)
else:
self.column = column_obj
if not self.row:
self.row = Row(row)
else:
self.row = row_obj
Cell.array[(row, column)] = self
class File_config(Node_Base):
__tablename__ = 'file_configs'
file_id = Column(db.Integer, primary_key=True, autoincrement=True)
node_id = Column(db.Integer, db.ForeignKey('nodes.node_id'))
file_name = Column(db.String(255))
file_path = Column(db.String(255))
service_name = Column(db.String(255))
created_at = Column(db.DateTime)
modified_at = Column(db.DateTime)
service_infos = relationship('Service_info',
secondary='service_info_file_config')
node = relationship('Node')
openstack_configs = relationship("Openstack_config",
back_populates="file_config")
def __repr__(self):
return "<File_config(file_id='%s',node_id='%s',file_name='%s',file_path='%s',service_name='%s',created_at='%s',modified_at='%s')>" % (
self.file_id, self.node_id, self.file_name, self.file_path,
self.service_name, self.created_at, self.modified_at)
def upload():
if 'file' not in request.files:
return make_response('No file sent', 400)
req_file = request.files['file']
if req_file.filename == '':
return make_response('No file selected', 400)
if req_file:
filename = secure_filename(req_file.filename)
parsed_file = parse(req_file, 500)
cols = []
for k, v in parsed_file.items():
cols.append(Column(name=k, data=v))
new_data = Data(created=datetime.datetime.now(), columns=cols)
req_file.stream.seek(0)
new_data.file.put(req_file,
content_type='text/csv',
filename=req_file.filename,
encoding='utf-8')
new_data.save()
result = {
'id':
str(new_data.id),
'name':
'Raw data',
'data':
lists_to_csv([{
'name': column.name,
'data': column.data
} for column in new_data.columns]),
'type':
constants.LINE_CHART
}
return jsonify(result), 200
class Metricdetail(Node_Base):
__tablename__ = 'metricdetails'
metricid = Column(db.Integer, primary_key=True, autoincrement=True)
metricname = Column(db.Text)
description = Column(db.Text)
displayname = Column(db.Text)
metrictype = Column(db.Integer)
datatype = Column(db.String(255))
protocolid = Column(db.Integer,
db.ForeignKey('protocoldetails.protocolid'))
protocoldetail = relationship("Protocoldetail")
alerts = relationship("Alert", back_populates="metricdetail")
polldatatemplate = relationship("Polldatatemplate",
back_populates="metricdetail")
polleddatas = relationship("Polleddata", back_populates="metricdetail")
def __repr__(self):
return "<Metricdetail(metricid='%s',metricname='%s',description='%s',displayname='%s',metrictype='%s',datatype='%s',protocolid='%s')>" % (
self.metricid, self.metricname, self.description, self.displayname,
self.metrictype, self.datatype, self.protocolid)
def double_click(self, index):
column = Column.get(index.row())
gui.ColChange.instance.set(column) if column else None
class Node(Node_Base):
__tablename__ = 'nodes'
node_id = Column(db.Integer, primary_key=True, autoincrement=True)
created_at = Column(db.DateTime)
updated_at = Column(db.DateTime)
deleted_at = Column(db.DateTime)
management_ip = Column(db.String(255))
ssh_user = Column(db.String(255))
ssh_password = Column(db.String(255))
status = Column(db.Text)
node_display_name = Column(db.String(255))
node_info_id = Column(db.String(255),
db.ForeignKey('node_infos.node_info_id'))
deployment_id = Column(db.Integer,
db.ForeignKey('deployments.deployment_id'))
node_type = Column(db.String(255))
node_info = relationship("Node_info")
deployment = relationship("Deployment")
service_infos = relationship("Service_info", back_populates="node")
node_roles = relationship("Node_role", back_populates="node")
def __repr__(self):
return "<Node(node_id='%s',created_at='%s',updated_at='%s',deleted_at='%s',management_ip='%s',ssh_user='******',ssh_password='******',status='%s',node_display_name='%s',node_info_id='%s',deployment_id='%s',node_type='%s')>" % (
self.node_id, self.created_at, self.updated_at, self.deleted_at,
self.management_ip, self.ssh_user, self.ssh_password, self.status,
self.node_display_name, self.node_info_id, self.deployment_id,
self.node_type)
class Alert(Node_Base):
__tablename__ = 'alert'
alertid = Column(db.String(255), primary_key=True, default=generate_uuid)
alarmRaisedTime = Column(db.BigInteger)
alarmChangedTime = Column(db.BigInteger)
alarmClearedTime = Column(db.BigInteger)
state = Column(db.String(45))
perceivedSeverity = Column(db.String(45))
eventTime = Column(db.Integer)
eventType = Column(db.String(255))
faultType = Column(db.String(255))
probableCause = Column(db.String(255))
isRootCause = Column(db.Integer)
correlatedAlarmId = Column(db.Integer)
faultDetails = Column(db.String(255))
deviceid = Column(db.Integer, db.ForeignKey('devicedetails.did'))
metricid = Column(db.Integer, db.ForeignKey('metricdetails.metricid'))
devicedetail = relationship("Devicedetail")
metricdetail = relationship("Metricdetail")
#
def __repr__(self):
return "<Alert(alertid='%s',alarmRaisedTime='%s',alarmChangedTime='%s',alarmClearedTime='%s',state='%s',perceivedSeverity='%s',eventTime='%s',eventType='%s',faultType='%s',probableCause='%s',isRootCause='%s',correlatedAlarmId='%s',faultDetails='%s',deviceid='%s',metricid='%s')>" % (
self.alertid, self.alarmRaisedTime, self.alarmChangedTime,
self.alarmClearedTime, self.state, self.perceivedSeverity,
self.eventTime, self.eventType, self.faultType, self.probableCause,
self.isRootCause, self.correlatedAlarmId, self.faultDetails,
self.deviceid, self.metricid)
training_data = csv.reader(csvfile, delimiter=',')
columns = []
column_names = []
path = create_dataset_folder(workspace_path)
send_json_message(0, 'Reading data')
for row in training_data:
column_count = 0
for item in row:
if line_count == 0:
column_names.append(item)
elif line_count == 1:
columns.append(
Column.create_column_with_item(
column_names[column_count], item))
else:
columns[column_count].process_item(item)
column_count += 1
line_count += 1
output_path = '%s/graph.json' % path
send_json_message(1, 'Saving graph')
output = []
for column in columns:
output.append(column.get_graph_data())
write_to_file(output, output_path, workspace_path)
copyfile(file_path,
get_actual_path('%s/data.csv' % path, workspace_path))
def update_columns_list(self):
begin = ColList.Model.createIndex(0, 0)
end = ColList.Model.createIndex(0, Column.count())
ColList.Model.dataChanged.emit(begin, end)
def fileSelected(self, controller, selection):
try:
print selection, type(selection)
if selection:
new_tables = []
selection_file_name = selection.getAbsolutePath()
logging.debug(selection_file_name)
controller.directory = os.path.dirname(selection.getAbsolutePath())
with open(selection_file_name) as f:
d = yaml.load(f.read())
print d
controller.app_name = d.get('app', os.path.splitext(os.path.basename(selection_file_name))[0])
for model in d.get('external_models', []):
model['external'] = True
for model in d.get('external_models', []) + d.get('models', []):
table = Table(name=model.get('name'),
x=model.get('x', random.randrange(int(controller.panX), int(width*controller.scaleXY + controller.panX))),
y=model.get('y', random.randrange(int(controller.panY), int(height*controller.scaleXY + controller.panY))),
display=model.get('display'),
natural_key=model.get('natural_key'),
natural_keys=model.get('natural_keys', []),
ordering=model.get('ordering', []),
external=model.get('external', False),
view=model.get('view', False),
extra=model.get('extra', False))
new_tables.append(table)
print "new table:", table
for field in model.get('fields'):
name = field.get('name')
ftype = field.get('type')
flen = field.get('len')
fdefault = field.get('default')
pk = field.get('pk', False)
related_name = field.get('related_name', None)
column = Column(name=":".join(map(str, filter(lambda x: x is not None, [name, ftype, flen or fdefault]))),
x=model.get('x', 0),
y=model.get('y', 0),
pk=pk,
related_name=related_name,
table=table)
print name, related_name
table.columns.append(column)
for model in d.get('models'):
ts = [t for t in new_tables if t.name == model.get('name')]
assert len(ts) == 1, "Duplicate model %s" % model.get('name')
from_table = ts[0]
for field in model.get('fields'):
if field.get('ref') and field.get('ref_field'):
cs = [c for c in from_table.columns if c.name.partition(":")[0] == field.get('name')]
assert len(cs) == 1
from_column = cs[0]
ts = [t for t in new_tables if t.name == field.get('ref')]
if len(ts) == 0:
new_table = Table(name=field.get('ref'),
x=random.randrange(int(controller.panX), int(width*controller.scaleXY + controller.panX)),
y=random.randrange(int(controller.panX), int(width*controller.scaleXY + controller.panX)),
external=True)
new_tables.append(new_table)
print "new external table:", table
ts = [new_table]
assert len(ts) == 1, repr(ts)
to_table = ts[0]
cs = [c for c in to_table.columns if c.name.partition(":")[0] == field.get('ref_field')]
if len(cs) == 0:
new_column = Column(name=field.get('ref_field'), x=0, y=0, pk=True, table=to_table)
to_table.columns.append(new_column)
cs = [new_column]
assert len(cs) == 1
to_column = cs[0]
from_column.connectors = [ForeignKey(from_column=from_column, to_column=to_column)]
elif field.get('ref'):
cs = [c for c in from_table.columns if c.name.partition(":")[0] == field.get('name')]
if len(cs) == 1:
from_column = cs[0]
ts = [t for t in new_tables if t.name == field.get('ref')]
if len(ts) == 0:
to_column = Column(name='pk')
to_table = Table(name=field.get('ref'), columns=[to_column])
to_column.table = to_table
new_tables.append(to_table)
from_column.connectors = [ForeignKey(from_column=from_column, to_column=to_column)]
elif len(ts) == 1:
to_table = ts[0]
to_column = to_table.columns[0]
from_column.connectors = [ForeignKey(from_column=from_column, to_column=to_column)]
else:
print "When connecting {0}.{1} expected one table named {2} found {3}".format(from_table.name,
from_column.name,
field.get('ref'),
ts)
else:
print "When connecting {0}.{1} expected one column named {2} found {3}".format(from_table.name,
field.get('name'),
field.get('name'),
cs)
view_d = d.get('view', {})
controller.modules = d.get('modules', [])
controller.api = d.get('api', None)
controller.generate = d.get('generate', None)
controller.panX = view_d.get('panX', 0)
controller.panY = view_d.get('panY', 0)
controller.scaleXY = view_d.get('scaleXY', 1)
controller.tables = new_tables
print "Read from {0}".format(selection)
controller.changeState(ReadyState)
except Exception:
print traceback.format_exc()
def column(self):
return Column.get(self.column_id)
def rowCount(self, QModelIndex_parent=None, *args, **kwargs):
return Column.count()
class Disk_resource(Node_Base):
__tablename__ = 'disk_resources'
disk_id = Column(db.String(255),primary_key=True,default=generate_uuid)
device_name=Column(db.String(255))
size= Column(db.Integer)
model=Column(db.String(255))
removable=Column(db.Integer)
sectors=Column(db.Text)
sectorsize=Column(db.Integer)
serial=Column(db.String(255))
vendor=Column(db.String(255))
support_discard=Column(db.String(255))
virtual=Column(db.Integer)
node_info_id=Column(db.String(255), db.ForeignKey('node_infos.node_info_id'))
node_info = relationship("Node_info")
def __repr__(self):
return "<Disk_resource(disk_id='%s',device_name='%s',size='%s',model='%s',removable='%s',sectors='%s',sectorsize='%s',serial='%s',vendor='%s',support_discard='%s',virtual='%s',node_info_id='%s')>" %(self.disk_id,self.device_name,self.size,self.model,self.removable,self.sectors,self.sectorsize,self.serial,self.vendor,self.support_discard,self.virtual,self.node_info_id)
