232 lines
9.5 KiB
Python
232 lines
9.5 KiB
Python
from datetime import timedelta
|
|
|
|
from colour import Color
|
|
from flask import g
|
|
from sqlalchemy import BigInteger, Boolean, CheckConstraint, Column, DateTime, Enum as DBEnum, \
|
|
ForeignKey, Integer, Interval, JSON, Sequence, SmallInteger, Unicode
|
|
from sqlalchemy.dialects.postgresql import UUID
|
|
from sqlalchemy.ext.declarative import declared_attr
|
|
from sqlalchemy.orm import backref, relationship, validates
|
|
from sqlalchemy.util import OrderedSet
|
|
from sqlalchemy_utils import ColorType
|
|
|
|
from ereuse_devicehub.db import db
|
|
from ereuse_devicehub.resources.device.models import Component, Device
|
|
from ereuse_devicehub.resources.event.enums import Appearance, Bios, Functionality, Orientation, \
|
|
SoftwareType, StepTypes, TestHardDriveLength
|
|
from ereuse_devicehub.resources.models import STR_BIG_SIZE, STR_SIZE, STR_SM_SIZE, Thing
|
|
from ereuse_devicehub.resources.user.models import User
|
|
from teal.db import CASCADE, CASCADE_OWN, INHERIT_COND, POLYMORPHIC_ID, POLYMORPHIC_ON, \
|
|
StrictVersionType, check_range
|
|
|
|
|
|
class JoinedTableMixin:
|
|
@declared_attr
|
|
def id(cls):
|
|
return Column(BigInteger, ForeignKey(Event.id), primary_key=True)
|
|
|
|
|
|
class Event(Thing):
|
|
id = Column(BigInteger, Sequence('event_seq'), primary_key=True)
|
|
title = Column(Unicode(STR_BIG_SIZE), default='', nullable=False)
|
|
date = Column(DateTime)
|
|
secured = Column(Boolean, default=False, nullable=False)
|
|
type = Column(Unicode)
|
|
incidence = Column(Boolean, default=False, nullable=False)
|
|
description = Column(Unicode, default='', nullable=False)
|
|
|
|
snapshot_id = Column(BigInteger, ForeignKey('snapshot.id',
|
|
use_alter=True,
|
|
name='snapshot_events'))
|
|
snapshot = relationship('Snapshot',
|
|
backref=backref('events',
|
|
lazy=True,
|
|
cascade=CASCADE,
|
|
collection_class=OrderedSet),
|
|
primaryjoin='Event.snapshot_id == Snapshot.id')
|
|
|
|
author_id = Column(UUID(as_uuid=True),
|
|
ForeignKey(User.id),
|
|
nullable=False,
|
|
default=lambda: g.user.id)
|
|
author = relationship(User,
|
|
backref=backref('events', lazy=True, collection_class=set),
|
|
primaryjoin=author_id == User.id)
|
|
components = relationship(Component,
|
|
backref=backref('events_components',
|
|
lazy=True,
|
|
order_by=lambda: Event.id,
|
|
collection_class=OrderedSet),
|
|
secondary=lambda: EventComponent.__table__,
|
|
order_by=lambda: Device.id,
|
|
collection_class=OrderedSet)
|
|
|
|
@declared_attr
|
|
def __mapper_args__(cls):
|
|
"""
|
|
Defines inheritance.
|
|
|
|
From `the guide <http://docs.sqlalchemy.org/en/latest/orm/
|
|
extensions/declarative/api.html
|
|
#sqlalchemy.ext.declarative.declared_attr>`_
|
|
"""
|
|
args = {POLYMORPHIC_ID: cls.t}
|
|
if cls.t == 'Event':
|
|
args[POLYMORPHIC_ON] = cls.type
|
|
if JoinedTableMixin in cls.mro():
|
|
args[INHERIT_COND] = cls.id == Event.id
|
|
return args
|
|
|
|
|
|
class EventComponent(db.Model):
|
|
device_id = Column(BigInteger, ForeignKey(Device.id), primary_key=True)
|
|
event_id = Column(BigInteger, ForeignKey(Event.id), primary_key=True)
|
|
|
|
|
|
class EventWithOneDevice(Event):
|
|
device_id = Column(BigInteger, ForeignKey(Device.id), nullable=False)
|
|
device = relationship(Device,
|
|
backref=backref('events_one',
|
|
lazy=True,
|
|
cascade=CASCADE,
|
|
order_by=lambda: EventWithOneDevice.id,
|
|
collection_class=OrderedSet),
|
|
primaryjoin=Device.id == device_id)
|
|
|
|
def __repr__(self) -> str:
|
|
return '<{0.t} {0.id!r} device={0.device!r}>'.format(self)
|
|
|
|
|
|
class EventWithMultipleDevices(Event):
|
|
"""
|
|
Note that these events are not deleted when a device is deleted.
|
|
"""
|
|
devices = relationship(Device,
|
|
backref=backref('events_multiple',
|
|
lazy=True,
|
|
order_by=lambda: EventWithMultipleDevices.id,
|
|
collection_class=OrderedSet),
|
|
secondary=lambda: EventDevice.__table__,
|
|
order_by=lambda: Device.id)
|
|
|
|
def __repr__(self) -> str:
|
|
return '<{0.t} {0.id!r} devices={0.devices!r}>'.format(self)
|
|
|
|
|
|
class EventDevice(db.Model):
|
|
device_id = Column(BigInteger, ForeignKey(Device.id), primary_key=True)
|
|
event_id = Column(BigInteger, ForeignKey(EventWithMultipleDevices.id), primary_key=True)
|
|
|
|
|
|
class Add(EventWithOneDevice):
|
|
pass
|
|
|
|
|
|
class Remove(EventWithOneDevice):
|
|
pass
|
|
|
|
|
|
class Allocate(JoinedTableMixin, EventWithMultipleDevices):
|
|
to_id = Column(UUID, ForeignKey(User.id))
|
|
to = relationship(User, primaryjoin=User.id == to_id)
|
|
organization = Column(Unicode(STR_SIZE))
|
|
|
|
|
|
class Deallocate(JoinedTableMixin, EventWithMultipleDevices):
|
|
from_id = Column(UUID, ForeignKey(User.id))
|
|
from_rel = relationship(User, primaryjoin=User.id == from_id)
|
|
organization = Column(Unicode(STR_SIZE))
|
|
|
|
|
|
class EraseBasic(JoinedTableMixin, EventWithOneDevice):
|
|
starting_time = Column(DateTime, nullable=False)
|
|
ending_time = Column(DateTime, nullable=False)
|
|
secure_random_steps = Column(SmallInteger, check_range('secure_random_steps', min=0),
|
|
nullable=False)
|
|
success = Column(Boolean, nullable=False)
|
|
clean_with_zeros = Column(Boolean, nullable=False)
|
|
|
|
|
|
class EraseSectors(EraseBasic):
|
|
pass
|
|
|
|
|
|
class Step(db.Model):
|
|
id = Column(BigInteger, Sequence('step_seq'), primary_key=True)
|
|
num = Column(SmallInteger, nullable=False)
|
|
type = Column(DBEnum(StepTypes), nullable=False)
|
|
success = Column(Boolean, nullable=False)
|
|
starting_time = Column(DateTime, nullable=False)
|
|
ending_time = Column(DateTime, CheckConstraint('ending_time > starting_time'), nullable=False)
|
|
secure_random_steps = Column(SmallInteger, check_range('secure_random_steps', min=0),
|
|
nullable=False)
|
|
clean_with_zeros = Column(Boolean, nullable=False)
|
|
|
|
erasure_id = Column(BigInteger, ForeignKey(EraseBasic.id))
|
|
erasure = relationship(EraseBasic, backref=backref('steps', cascade=CASCADE_OWN))
|
|
|
|
|
|
class Snapshot(JoinedTableMixin, EventWithOneDevice):
|
|
uuid = Column(UUID(as_uuid=True), nullable=False, unique=True) # type: UUID
|
|
version = Column(StrictVersionType(STR_SM_SIZE), nullable=False) # type: str
|
|
software = Column(DBEnum(SoftwareType), nullable=False) # type: SoftwareType
|
|
appearance = Column(DBEnum(Appearance)) # type: Appearance
|
|
appearance_score = Column(SmallInteger,
|
|
check_range('appearance_score', -3, 5)) # type: int
|
|
functionality = Column(DBEnum(Functionality)) # type: Functionality
|
|
functionality_score = Column(SmallInteger,
|
|
check_range('functionality_score', min=-3, max=5)) # type: int
|
|
labelling = Column(Boolean) # type: bool
|
|
bios = Column(DBEnum(Bios)) # type: Bios
|
|
condition = Column(SmallInteger,
|
|
check_range('condition', min=0, max=5)) # type: int
|
|
elapsed = Column(Interval, nullable=False) # type: timedelta
|
|
install_name = Column(Unicode(STR_BIG_SIZE)) # type: str
|
|
install_elapsed = Column(Interval) # type: timedelta
|
|
install_success = Column(Boolean) # type: bool
|
|
inventory_elapsed = Column(Interval) # type: timedelta
|
|
color = Column(ColorType) # type: Color
|
|
orientation = Column(DBEnum(Orientation)) # type: Orientation
|
|
|
|
@validates('components')
|
|
def validate_components_only_workbench(self, _, components):
|
|
if self.software != SoftwareType.Workbench:
|
|
if components:
|
|
raise ValueError('Only Snapshots from Workbench can have components.')
|
|
return components
|
|
|
|
|
|
class SnapshotRequest(db.Model):
|
|
id = Column(BigInteger, ForeignKey(Snapshot.id), primary_key=True)
|
|
request = Column(JSON, nullable=False)
|
|
|
|
snapshot = relationship(Snapshot,
|
|
backref=backref('request',
|
|
lazy=True,
|
|
uselist=False,
|
|
cascade=CASCADE_OWN))
|
|
|
|
|
|
class Test(JoinedTableMixin, EventWithOneDevice):
|
|
elapsed = Column(Interval, nullable=False)
|
|
success = Column(Boolean, nullable=False)
|
|
|
|
snapshot = relationship(Snapshot, backref=backref('tests',
|
|
lazy=True,
|
|
cascade=CASCADE_OWN,
|
|
order_by=Event.id,
|
|
collection_class=OrderedSet))
|
|
|
|
|
|
class TestHardDrive(Test):
|
|
id = Column(BigInteger, ForeignKey(Test.id), primary_key=True)
|
|
length = Column(DBEnum(TestHardDriveLength), nullable=False) # todo from type
|
|
status = Column(Unicode(STR_SIZE), nullable=False)
|
|
lifetime = Column(Interval, nullable=False)
|
|
first_error = Column(Integer)
|
|
# todo error becomes Test.success
|
|
|
|
|
|
class StressTest(Test):
|
|
pass
|