class RackEntry(db.Model):
__tablename__ = "racks"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
label = db.Column(db.String(80))
datacenter_id = db.Column(db.Integer)
pdu_left = db.Column(pg.ARRAY(db.Integer))
pdu_right = db.Column(pg.ARRAY(db.Integer))
def __init__(self, rack: Rack):
self.label = rack.label
self.datacenter_id = rack.datacenter_id
self.pdu_left = rack.pdu_left
self.pdu_right = rack.pdu_right
def make_rack(self) -> Rack:
""" Convert the database entry to a rack """
return Rack(
label=self.label,
datacenter_id=self.datacenter_id,
pdu_left=self.pdu_left,
pdu_right=self.pdu_right,
)
def make_json(self) -> JSON:
return {
"label": self.label,
"datacenter_id": self.datacenter_id,
"pdu_left": self.pdu_left,
"pdu_right": self.pdu_right,
}
class ChangePlanEntry(db.Model):
__tablename__ = "changePlan"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
owner = db.Column(db.String(128))
name = db.Column(db.String(128))
executed = db.Column(db.Boolean)
timestamp = db.Column(db.String(120), nullable=True)
def __init__(self, change_plan: ChangePlan):
self.owner = change_plan.owner
self.name = change_plan.name
self.executed = change_plan.executed
if change_plan.timestamp == "":
self.timestamp = None
else:
self.timestamp = change_plan.timestamp
if change_plan.identifier != -1:
self.identifier = change_plan.identifier
def make_change_plan(self) -> ChangePlan:
""" Convert the database entry to a datacenter """
return ChangePlan(
owner=self.owner,
name=self.name,
executed=self.executed,
timestamp=self.timestamp,
identifier=self.identifier,
)
class DatacenterEntry(db.Model):
__tablename__ = "datacenters"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
abbreviation = db.Column(db.String(10), unique=True)
name = db.Column(db.String(128), unique=True)
is_offline_storage = db.Column(db.Boolean)
def __init__(self, datacenter: Datacenter):
self.abbreviation = datacenter.abbreviation
self.name = datacenter.name
self.is_offline_storage = datacenter.is_offline_storage
def make_datacenter(self) -> Datacenter:
""" Convert the database entry to a datacenter """
return Datacenter(
abbreviation=self.abbreviation,
name=self.name,
is_offline_storage=self.is_offline_storage,
)
class UserEntry(db.Model):
__tablename__ = "users"
username = db.Column(db.String(80), primary_key=True, unique=True)
password_hash = db.Column(db.Binary(512))
display_name = db.Column(db.String(80))
email = db.Column(db.String(80))
privilege = db.Column(pg.JSON, nullable=True)
datacenters = db.Column(pg.ARRAY(Text), nullable=True)
def __init__(self, user: User):
self.username = user.username
self.password_hash = user.password
self.display_name = user.display_name
self.email = user.email
self.privilege = user.privilege
self.datacenters = user.datacenters
class DecommissionEntry(db.Model):
__tablename__ = "decomission"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
vendor = db.Column(db.String(80))
model_number = db.Column(db.String(80))
height = db.Column(db.Integer)
hostname = db.Column(db.String(80), nullable=True)
rack_label = db.Column(db.String(80))
rack_position = db.Column(db.Integer)
owner = db.Column(db.String(80), nullable=True)
comment = db.Column(db.String(80), nullable=True)
datacenter_name = db.Column(db.String(80))
network_connections = db.Column(pg.JSON, nullable=True)
power_connections = db.Column(pg.ARRAY(db.String(50)), nullable=True)
asset_number = db.Column(db.Integer)
chassis_hostname = db.Column(db.String(80), nullable=True)
chassis_slot = db.Column(db.Integer, nullable=True)
decommission_user = db.Column(db.String(80))
timestamp = db.Column(db.String(120))
network_neighborhood = db.Column(pg.JSON, nullable=True)
def __init__(self, decommission: Decommission):
self.vendor = decommission.vendor
self.model_number = decommission.model_number
self.height = decommission.height
self.hostname = decommission.hostname
self.rack_label = decommission.rack_label
self.rack_position = decommission.rack_position
self.owner = decommission.owner
self.comment = decommission.comment
self.datacenter_name = decommission.datacenter_name
self.network_connections = decommission.network_connections
self.power_connections = decommission.power_connections
self.asset_number = decommission.asset_number
self.chassis_hostname = decommission.chassis_hostname
self.chassis_slot = decommission.chassis_slot
self.decommission_user = decommission.decommission_user
self.timestamp = decommission.timestamp
self.network_neighborhood = decommission.network_neighborhood
def make_decommission(self) -> Decommission:
""" Convert the database entry to an instance """
return Decommission(
vendor=self.vendor,
model_number=self.model_number,
height=self.height,
hostname=self.hostname,
rack_label=self.rack_label,
rack_position=self.rack_position,
owner=self.owner,
comment=self.comment,
datacenter_name=self.datacenter_name,
network_connections=self.network_connections,
power_connections=self.power_connections,
asset_number=self.asset_number,
chassis_hostname=self.chassis_hostname,
chassis_slot=self.chassis_slot,
timestamp=self.timestamp,
decommission_user=self.decommission_user,
network_neighborhood=self.network_neighborhood,
)
class InstanceEntry(db.Model):
__tablename__ = "instances"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
model_id = db.Column(db.Integer)
hostname = db.Column(db.String(80), nullable=True)
rack_label = db.Column(db.String(80))
rack_position = db.Column(db.Integer)
owner = db.Column(db.String(80), nullable=True)
comment = db.Column(db.String(80), nullable=True)
datacenter_id = db.Column(db.Integer)
network_connections = db.Column(pg.JSON, nullable=True)
power_connections = db.Column(pg.ARRAY(db.String(50)), nullable=True)
asset_number = db.Column(db.Integer)
mount_type = db.Column(db.String(32))
display_color = db.Column(db.String(80), nullable=True)
cpu = db.Column(db.String(80), nullable=True)
memory = db.Column(db.Integer, nullable=True)
storage = db.Column(db.String(80), nullable=True)
chassis_hostname = db.Column(db.String(80), nullable=True)
chassis_slot = db.Column(db.Integer, nullable=True)
def __init__(self, instance: Instance):
self.model_id = instance.model_id
self.hostname = instance.hostname
self.rack_label = instance.rack_label
self.rack_position = instance.rack_position
self.owner = instance.owner
self.comment = instance.comment
self.datacenter_id = instance.datacenter_id
self.network_connections = instance.network_connections
self.power_connections = instance.power_connections
self.asset_number = instance.asset_number
self.mount_type = instance.mount_type
# Model Vals
self.display_color = instance.display_color
self.cpu = instance.cpu
self.memory = instance.memory
self.storage = instance.storage
# Chassis Reference
self.chassis_hostname = instance.chassis_hostname
self.chassis_slot = instance.chassis_slot
def make_instance(self) -> Instance:
""" Convert the database entry to an instance """
return Instance(
model_id=self.model_id,
hostname=self.hostname,
rack_label=self.rack_label,
rack_position=self.rack_position,
owner=self.owner,
comment=self.comment,
datacenter_id=self.datacenter_id,
network_connections=self.network_connections,
power_connections=self.power_connections,
asset_number=self.asset_number,
mount_type=self.mount_type,
display_color=self.display_color,
cpu=self.cpu,
memory=self.memory,
storage=self.storage,
chassis_hostname=self.chassis_hostname,
chassis_slot=self.chassis_slot,
)
def make_json(self) -> JSON:
return {
"model_id": self.model_id,
"hostname": self.hostname,
"rack_label": self.rack_label,
"rack_position": self.rack_position,
"owner": self.owner,
"comment": self.comment,
"datacenter_id": self.datacenter_id,
"network_connections": self.network_connections,
"power_connections": self.power_connections,
"asset_number": self.asset_number,
"mount_type": self.mount_type,
"display_color": self.display_color,
"cpu": self.cpu,
"memory": self.memory,
"storage": self.storage,
"chassis_hostname": self.chassis_hostname,
"chassis_slot": self.chassis_slot,
}
class ModelEntry(db.Model):
__tablename__ = "models"
identifier = db.Column(db.Integer, primary_key=True, unique=True)
vendor = db.Column(db.String(80))
model_number = db.Column(db.String(80))
height = db.Column(db.Integer, nullable=True)
display_color = db.Column(db.String(80), nullable=True)
ethernet_ports = db.Column(pg.ARRAY(db.String(80)), nullable=True)
power_ports = db.Column(db.Integer, nullable=True)
cpu = db.Column(db.String(80), nullable=True)
memory = db.Column(db.Integer, nullable=True)
storage = db.Column(db.String(80), nullable=True)
comment = db.Column(db.String(80), nullable=True)
mount_type = db.Column(db.String(32))
def __init__(self, model: Model):
self.vendor = model.vendor
self.model_number = model.model_number
self.height = model.height
self.display_color = model.display_color
self.ethernet_ports = model.ethernet_ports
self.power_ports = model.power_ports
self.cpu = model.cpu
self.memory = model.memory
self.storage = model.storage
self.comment = model.comment
self.mount_type = model.mount_type
def make_json(self) -> JSON:
return {
"vendor": self.vendor,
"model_number": self.model_number,
"height": self.height,
"display_color": self.display_color,
"ethernet_ports": self.ethernet_ports,
"power_ports": self.power_ports,
"cpu": self.cpu,
"memory": self.memory,
"storage": self.storage,
"comment": self.comment,
"mount_type": self.mount_type,
}
def make_model(self) -> Model:
return Model(
vendor=self.vendor,
model_number=self.model_number,
height=self.height,
ethernet_ports=self.ethernet_ports,
power_ports=self.power_ports,
cpu=self.cpu,
memory=self.memory,
storage=self.storage,
comment=self.comment,
display_color=self.display_color,
mount_type=self.mount_type,
)