Remove old models

37 files changed, 0 insertions, 1520 deletions

diff --git a/web-server/opendc/api/v2/experiments/experimentId/machine-states/__init__.py b/web-server/opendc/api/v2/experiments/experimentId/machine-states/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/machine-states/__init__.py
+++ /dev/null
diff --git a/web-server/opendc/api/v2/experiments/experimentId/machine-states/endpoint.py b/web-server/opendc/api/v2/experiments/experimentId/machine-states/endpoint.py
deleted file mode 100644
index c7dcad9a..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/machine-states/endpoint.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from opendc.models_old.experiment import Experiment
-from opendc.models_old.machine_state import MachineState
-from opendc.util import exceptions
-from opendc.util.rest import Response
-
-
-def GET(request):
-    """Get this Experiment's Machine States."""
-
-    # Make sure required parameters are there
-
-    try:
-        request.check_required_parameters(path={'experimentId': 'int'})
-
-    except exceptions.ParameterError as e:
-        return Response(400, str(e))
-
-    # Instantiate an Experiment from the database
-
-    experiment = Experiment.from_primary_key((request.params_path['experimentId'], ))
-
-    # Make sure this Experiment exists
-
-    if not experiment.exists():
-        return Response(404, '{} not found.'.format(experiment))
-
-    # Make sure this user is authorized to view this Experiment's Machine States
-
-    if not experiment.google_id_has_at_least(request.google_id, 'VIEW'):
-        return Response(403, 'Forbidden from viewing Machine States for {}.'.format(experiment))
-
-    # Get and return the Machine States
-
-    if 'tick' in request.params_query:
-        machine_states = MachineState.from_experiment_id_and_tick(request.params_path['experimentId'],
-                                                                  request.params_query['tick'])
-
-    else:
-        machine_states = MachineState.from_experiment_id(request.params_path['experimentId'])
-
-    return Response(200, 'Successfully retrieved Machine States for {}.'.format(experiment),
-                    [x.to_JSON() for x in machine_states])
diff --git a/web-server/opendc/api/v2/experiments/experimentId/rack-states/__init__.py b/web-server/opendc/api/v2/experiments/experimentId/rack-states/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/rack-states/__init__.py
+++ /dev/null
diff --git a/web-server/opendc/api/v2/experiments/experimentId/rack-states/endpoint.py b/web-server/opendc/api/v2/experiments/experimentId/rack-states/endpoint.py
deleted file mode 100644
index f3acf56a..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/rack-states/endpoint.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from opendc.models_old.experiment import Experiment
-from opendc.models_old.rack_state import RackState
-from opendc.util import exceptions
-from opendc.util.rest import Response
-
-
-def GET(request):
-    """Get this Experiment's Tack States."""
-
-    # Make sure required parameters are there
-
-    try:
-        request.check_required_parameters(path={'experimentId': 'int'})
-
-    except exceptions.ParameterError as e:
-        return Response(400, str(e))
-
-    # Instantiate an Experiment from the database
-
-    experiment = Experiment.from_primary_key((request.params_path['experimentId'], ))
-
-    # Make sure this Experiment exists
-
-    if not experiment.exists():
-        return Response(404, '{} not found.'.format(experiment))
-
-    # Make sure this user is authorized to view this Experiment's Rack States
-
-    if not experiment.google_id_has_at_least(request.google_id, 'VIEW'):
-        return Response(403, 'Forbidden from viewing Rack States for {}.'.format(experiment))
-
-    # Get and return the Rack States
-
-    if 'tick' in request.params_query:
-        rack_states = RackState.from_experiment_id_and_tick(request.params_path['experimentId'],
-                                                            request.params_query['tick'])
-
-    else:
-        rack_states = RackState.from_experiment_id(request.params_path['experimentId'])
-
-    return Response(200, 'Successfully retrieved Rack States for {}.'.format(experiment),
-                    [x.to_JSON() for x in rack_states])
diff --git a/web-server/opendc/api/v2/experiments/experimentId/room-states/__init__.py b/web-server/opendc/api/v2/experiments/experimentId/room-states/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/room-states/__init__.py
+++ /dev/null
diff --git a/web-server/opendc/api/v2/experiments/experimentId/room-states/endpoint.py b/web-server/opendc/api/v2/experiments/experimentId/room-states/endpoint.py
deleted file mode 100644
index db3f8b14..00000000
--- a/web-server/opendc/api/v2/experiments/experimentId/room-states/endpoint.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from opendc.models_old.experiment import Experiment
-from opendc.models_old.room_state import RoomState
-from opendc.util import exceptions
-from opendc.util.rest import Response
-
-
-def GET(request):
-    """Get this Experiment's Room States."""
-
-    # Make sure required parameters are there
-
-    try:
-        request.check_required_parameters(path={'experimentId': 'int'})
-
-    except exceptions.ParameterError as e:
-        return Response(400, str(e))
-
-    # Instantiate an Experiment from the database
-
-    experiment = Experiment.from_primary_key((request.params_path['experimentId'], ))
-
-    # Make sure this Experiment exists
-
-    if not experiment.exists():
-        return Response(404, '{} not found.'.format(experiment))
-
-    # Make sure this user is authorized to view this Experiment's Room States
-
-    if not experiment.google_id_has_at_least(request.google_id, 'VIEW'):
-        return Response(403, 'Forbidden from viewing Room States for {}.'.format(experiment))
-
-    # Get and return the Room States
-
-    if 'tick' in request.params_query:
-        room_states = RoomState.from_experiment_id_and_tick(request.params_path['experimentId'],
-                                                            request.params_query['tick'])
-
-    else:
-        room_states = RoomState.from_experiment_id(request.params_path['experimentId'])
-
-    return Response(200, 'Successfully retrieved Room States for {}.'.format(experiment),
-                    [x.to_JSON() for x in room_states])
diff --git a/web-server/opendc/models_old/__init__.py b/web-server/opendc/models_old/__init__.py
deleted file mode 100644
index e69de29b..00000000
--- a/web-server/opendc/models_old/__init__.py
+++ /dev/null
diff --git a/web-server/opendc/models_old/allowed_object.py b/web-server/opendc/models_old/allowed_object.py
deleted file mode 100644
index bcadf025..00000000
--- a/web-server/opendc/models_old/allowed_object.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class AllowedObject(Model):
-    JSON_TO_PYTHON_DICT = {'AllowedObject': {'roomType': 'room_type', 'objectType': 'object_type'}}
-
-    COLLECTION_NAME = 'allowed_objects'
-    COLUMNS = ['room_type', 'object_type']
-    COLUMNS_PRIMARY_KEY = ['room_type', 'object_type']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this AllowedObject."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
-
-    def to_JSON(self):
-        """Return a JSON representation of this AllowedObject."""
-
-        return self.object_type
diff --git a/web-server/opendc/models_old/authorization.py b/web-server/opendc/models_old/authorization.py
deleted file mode 100644
index 43d784e9..00000000
--- a/web-server/opendc/models_old/authorization.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.user import User
-
-
-class Authorization(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Authorization': {
-            'userId': 'user_id',
-            'simulationId': 'simulation_id',
-            'authorizationLevel': 'authorization_level'
-        }
-    }
-
-    COLLECTION_NAME = 'authorizations'
-    COLUMNS = ['user_id', 'simulation_id', 'authorization_level']
-    COLUMNS_PRIMARY_KEY = ['user_id', 'simulation_id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this Authorization."""
-
-        authorization = Authorization.from_primary_key((User.from_google_id(google_id).id, self.simulation_id))
-
-        if authorization is None:
-            return False
-
-        return authorization.has_at_least(authorization_level)
-
-    def has_at_least(self, required_level):
-        """Return True if this Authorization has at least the required level."""
-
-        if not self.exists():
-            return False
-
-        authorization_levels = ['VIEW', 'EDIT', 'OWN']
-
-        try:
-            index_actual = authorization_levels.index(self.authorization_level)
-            index_required = authorization_levels.index(required_level)
-        except:
-            return False
-
-        if index_actual >= index_required:
-            return True
-        else:
-            return False
diff --git a/web-server/opendc/models_old/cpu.py b/web-server/opendc/models_old/cpu.py
deleted file mode 100644
index 0f50ce1c..00000000
--- a/web-server/opendc/models_old/cpu.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class CPU(Model):
-    JSON_TO_PYTHON_DICT = {
-        'CPU': {
-            'id': 'id',
-            'manufacturer': 'manufacturer',
-            'family': 'family',
-            'generation': 'generation',
-            'model': 'model',
-            'clockRateMhz': 'clock_rate_mhz',
-            'numberOfCores': 'number_of_cores',
-            'energyConsumptionW': 'energy_consumption_w',
-            'failureModelId': 'failure_model_id'
-        }
-    }
-
-    COLLECTION_NAME = 'cpus'
-
-    COLUMNS = [
-        'id', 'manufacturer', 'family', 'generation', 'model', 'clock_rate_mhz', 'number_of_cores',
-        'energy_consumption_w', 'failure_model_id'
-    ]
-
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this CPU."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/datacenter.py b/web-server/opendc/models_old/datacenter.py
deleted file mode 100644
index b1ed2eee..00000000
--- a/web-server/opendc/models_old/datacenter.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.section import Section
-
-
-class Datacenter(Model):
-    JSON_TO_PYTHON_DICT = {'datacenter': {'id': 'id', 'starred': 'starred', 'simulationId': 'simulation_id'}}
-
-    PATH = '/v1/simulations/{simulationId}/datacenters'
-
-    COLLECTION_NAME = 'datacenters'
-    COLUMNS = ['id', 'simulation_id', 'starred']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Datacenter."""
-
-        # Get a Section that contains this Datacenter. It doesn't matter which one, since all Sections that have this
-        # Datacenter belong to the same Simulation, so the User's Authorization is the same for each one.
-
-        try:
-            section = Section.query('datacenter_id', self.id)[0]
-        except:
-            return False
-
-        # Check the Section's Authorization
-
-        return section.google_id_has_at_least(google_id, authorization_level)
diff --git a/web-server/opendc/models_old/experiment.py b/web-server/opendc/models_old/experiment.py
deleted file mode 100644
index 64b99212..00000000
--- a/web-server/opendc/models_old/experiment.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.simulation import Simulation
-from opendc.util import exceptions
-
-
-class Experiment(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Experiment': {
-            'id': 'id',
-            'simulationId': 'simulation_id',
-            'pathId': 'path_id',
-            'traceId': 'trace_id',
-            'schedulerName': 'scheduler_name',
-            'name': 'name',
-            'state': 'state',
-            'lastSimulatedTick': 'last_simulated_tick'
-        }
-    }
-
-    COLLECTION_NAME = 'experiments'
-    COLUMNS = ['id', 'simulation_id', 'path_id', 'trace_id', 'scheduler_name', 'name', 'state', 'last_simulated_tick']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Experiment."""
-
-        # Get the Simulation
-
-        try:
-            simulation = Simulation.from_primary_key((self.simulation_id, ))
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Simulation's Authorization
-
-        return simulation.google_id_has_at_least(google_id, authorization_level)
diff --git a/web-server/opendc/models_old/failure_model.py b/web-server/opendc/models_old/failure_model.py
deleted file mode 100644
index d1a8c1cc..00000000
--- a/web-server/opendc/models_old/failure_model.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class FailureModel(Model):
-    JSON_TO_PYTHON_DICT = {'FailureModel': {'id': 'id', 'name': 'name', 'rate': 'rate'}}
-
-    COLLECTION_NAME = 'failure_models'
-    COLUMNS = ['id', 'name', 'rate']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this FailureModel."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/gpu.py b/web-server/opendc/models_old/gpu.py
deleted file mode 100644
index 31b3b6b1..00000000
--- a/web-server/opendc/models_old/gpu.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class GPU(Model):
-    JSON_TO_PYTHON_DICT = {
-        'GPU': {
-            'id': 'id',
-            'manufacturer': 'manufacturer',
-            'family': 'family',
-            'generation': 'generation',
-            'model': 'model',
-            'clockRateMhz': 'clock_rate_mhz',
-            'numberOfCores': 'number_of_cores',
-            'energyConsumptionW': 'energy_consumption_w',
-            'failureModelId': 'failure_model_id'
-        }
-    }
-
-    COLLECTION_NAME = 'gpus'
-
-    COLUMNS = [
-        'id', 'manufacturer', 'family', 'generation', 'model', 'clock_rate_mhz', 'number_of_cores',
-        'energy_consumption_w', 'failure_model_id'
-    ]
-
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this GPU."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/job.py b/web-server/opendc/models_old/job.py
deleted file mode 100644
index 9cb7cd7e..00000000
--- a/web-server/opendc/models_old/job.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Job(Model):
-    JSON_TO_PYTHON_DICT = {'Job': {'id': 'id', 'name': 'name'}}
-
-    COLLECTION_NAME = 'jobs'
-    COLUMNS = ['id', 'name']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Job."""
-
-        return authorization_level not in ['EDIT', 'OWN']
diff --git a/web-server/opendc/models_old/machine.py b/web-server/opendc/models_old/machine.py
deleted file mode 100644
index 8e5ccb44..00000000
--- a/web-server/opendc/models_old/machine.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import copy
-
-from opendc.models_old.model import Model
-from opendc.models_old.rack import Rack
-from opendc.util import database, exceptions
-
-
-class Machine(Model):
-    JSON_TO_PYTHON_DICT = {
-        'machine': {
-            'id': 'id',
-            'rackId': 'rack_id',
-            'position': 'position',
-            'tags': 'tags',
-            'cpuIds': 'cpu_ids',
-            'gpuIds': 'gpu_ids',
-            'memoryIds': 'memory_ids',
-            'storageIds': 'storage_ids',
-            'topologyId': 'topology_id'
-        }
-    }
-
-    PATH = '/v1/tiles/{tileId}/rack/machines'
-
-    COLLECTION_NAME = 'machines'
-    COLUMNS = ['id', 'rack_id', 'position', 'topology_id']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    device_table_to_attribute = {
-        'cpus': 'cpu_ids',
-        'gpus': 'gpu_ids',
-        'memories': 'memory_ids',
-        'storages': 'storage_ids'
-    }
-
-    def _update_devices(self, before_insert):
-        """Update this Machine's devices in the database."""
-
-        for device_table in self.device_table_to_attribute.keys():
-
-            # First, delete current machine-device links
-
-            statement = 'DELETE FROM machine_{} WHERE machine_id = %s'.format(device_table)
-            database.execute(statement, (before_insert.id, ))
-
-            # Then, add current ones
-
-            for device_id in getattr(before_insert, before_insert.device_table_to_attribute[device_table]):
-                statement = 'INSERT INTO machine_{} (machine_id, {}) VALUES (%s, %s)'.format(
-                    device_table, before_insert.device_table_to_attribute[device_table][:-1])
-
-                database.execute(statement, (before_insert.id, device_id))
-
-    @classmethod
-    def from_tile_id_and_rack_position(cls, tile_id, position):
-        """Get a Rack from the ID of the tile its Rack is on, and its position in the Rack."""
-
-        try:
-            rack = Rack.from_tile_id(tile_id)
-        except:
-            return cls(id=-1)
-
-        try:
-            statement = 'SELECT id FROM machines WHERE rack_id = %s AND position = %s'
-            machine_id = database.fetch_one(statement, (rack.id, position))[0]
-        except:
-            return cls(id=-1)
-
-        return cls.from_primary_key((machine_id, ))
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Machine."""
-
-        # Get the Rack
-
-        try:
-            rack = Rack.from_primary_key((self.rack_id, ))
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Rack's Authorization
-
-        return rack.google_id_has_at_least(google_id, authorization_level)
-
-    def insert(self):
-        """Insert this Machine by also updating its devices."""
-
-        before_insert = copy.deepcopy(self)
-
-        super(Machine, self).insert()
-
-        before_insert.id = self.id
-        self._update_devices(before_insert)
-
-    def read(self):
-        """Read this Machine by also getting its CPU, GPU, Memory and Storage IDs."""
-
-        super(Machine, self).read()
-
-        for device_table in self.device_table_to_attribute.keys():
-
-            statement = 'SELECT * FROM machine_{} WHERE machine_id = %s'.format(device_table)
-            results = database.fetch_all(statement, (self.id, ))
-
-            device_ids = []
-
-            for row in results:
-                device_ids.append(row[2])
-
-            setattr(self, self.device_table_to_attribute[device_table], device_ids)
-
-        setattr(self, 'tags', [])
-
-    def update(self):
-        """Update this Machine by also updating its devices."""
-
-        before_update = copy.deepcopy(self)
-
-        super(Machine, self).update()
-
-        before_update.id = self.id
-        self._update_devices(before_update)
diff --git a/web-server/opendc/models_old/machine_state.py b/web-server/opendc/models_old/machine_state.py
deleted file mode 100644
index 0e9f7dad..00000000
--- a/web-server/opendc/models_old/machine_state.py
+++ /dev/null
@@ -1,71 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.util import database
-
-
-class MachineState(Model):
-    JSON_TO_PYTHON_DICT = {
-        'MachineState': {
-            'machineId': 'machine_id',
-            'temperatureC': 'temperature_c',
-            'inUseMemoryMb': 'in_use_memory_mb',
-            'loadFraction': 'load_fraction',
-            'tick': 'tick'
-        }
-    }
-
-    COLLECTION_NAME = 'machine_states'
-    COLUMNS = ['id', 'machine_id', 'experiment_id', 'tick', 'temperature_c', 'in_use_memory_mb', 'load_fraction']
-
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    @classmethod
-    def _from_database_row(cls, row):
-        """Instantiate a MachineState from a database row (including tick from the TaskState)."""
-
-        return cls(machine_id=row[1], temperature_c=row[4], in_use_memory_mb=row[5], load_fraction=row[6], tick=row[3])
-
-    @classmethod
-    def from_experiment_id(cls, experiment_id):
-        """Query MachineStates by their Experiment id."""
-
-        machine_states = []
-
-        statement = 'SELECT * FROM machine_states WHERE experiment_id = %s'
-        results = database.fetch_all(statement, (experiment_id, ))
-
-        for row in results:
-            machine_states.append(cls._from_database_row(row))
-
-        return machine_states
-
-    @classmethod
-    def from_experiment_id_and_tick(cls, experiment_id, tick):
-        """Query MachineStates by their Experiment id and tick."""
-
-        machine_states = []
-
-        statement = 'SELECT * FROM machine_states WHERE experiment_id = %s AND machine_states.tick = %s'
-        results = database.fetch_all(statement, (experiment_id, tick))
-
-        for row in results:
-            machine_states.append(cls._from_database_row(row))
-
-        return machine_states
-
-    def read(self):
-        """Read this MachineState by also getting its tick."""
-
-        super(MachineState, self).read()
-
-        statement = 'SELECT tick FROM task_states WHERE id = %s'
-        result = database.fetch_one(statement, (self.task_state_id, ))
-
-        self.tick = result[0]
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this MachineState."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/memory.py b/web-server/opendc/models_old/memory.py
deleted file mode 100644
index 8edf8f5d..00000000
--- a/web-server/opendc/models_old/memory.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Memory(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Memory': {
-            'id': 'id',
-            'manufacturer': 'manufacturer',
-            'family': 'family',
-            'generation': 'generation',
-            'model': 'model',
-            'speedMbPerS': 'speed_mb_per_s',
-            'sizeMb': 'size_mb',
-            'energyConsumptionW': 'energy_consumption_w',
-            'failureModelId': 'failure_model_id'
-        }
-    }
-
-    COLLECTION_NAME = 'memories'
-
-    COLUMNS = [
-        'id', 'manufacturer', 'family', 'generation', 'model', 'speed_mb_per_s', 'size_mb', 'energy_consumption_w',
-        'failure_model_id'
-    ]
-
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this Memory."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/model.py b/web-server/opendc/models_old/model.py
deleted file mode 100644
index 73eabd26..00000000
--- a/web-server/opendc/models_old/model.py
+++ /dev/null
@@ -1,303 +0,0 @@
-from opendc.util import database, exceptions
-
-
-class Model(object):
-    # MUST OVERRIDE IN DERIVED CLASS
-
-    JSON_TO_PYTHON_DICT = {'Model': {'jsonParameterName': 'python_parameter_name'}}
-
-    PATH = ''
-    PATH_PARAMETERS = {}
-
-    COLLECTION_NAME = ''
-    COLUMNS = []
-    COLUMNS_PRIMARY_KEY = []
-
-    # INITIALIZATION
-
-    def __init__(self, **kwargs):
-        """Initialize a model from its keyword arguments."""
-
-        for name, value in kwargs.items():
-            setattr(self, name, value)
-
-    def __repr__(self):
-        """Return a string representation of this object."""
-
-        identifiers = []
-
-        for attribute in self.COLUMNS_PRIMARY_KEY:
-            identifiers.append('{} = {}'.format(attribute, getattr(self, attribute)))
-
-        return '{} ({})'.format(self.COLLECTION_NAME[:-1].title().replace('_', ''), '; '.join(identifiers))
-
-    # JSON CONVERSION METHODS
-
-    @classmethod
-    def from_JSON(cls, json_object):
-        """Initialize a Model from its JSON object representation."""
-
-        parameters = {}
-        parameter_map = cls.JSON_TO_PYTHON_DICT.values()[0]
-
-        for json_name in parameter_map:
-
-            python_name = parameter_map[json_name]
-
-            if json_name in json_object:
-                parameters[python_name] = json_object.get(json_name)
-
-            else:
-                parameters[python_name] = None
-
-        return cls(**parameters)
-
-    def to_JSON(self):
-        """Return a JSON-serializable object representation of this Model."""
-
-        parameters = {}
-        parameter_map = self.JSON_TO_PYTHON_DICT.values()[0]
-
-        for json_name in parameter_map:
-
-            python_name = parameter_map[json_name]
-
-            if hasattr(self, python_name):
-                parameters[json_name] = getattr(self, python_name)
-
-            else:
-                parameters[json_name] = None
-
-        return parameters
-
-    # API CALL GENERATION
-
-    def generate_api_call(self, path_parameters, token):
-        """Return a message that can be executed by a Request to recreate this object."""
-
-        return {
-            'id': 0,
-            'path': self.PATH,
-            'method': 'POST',
-            'parameters': {
-                'body': {
-                    self.JSON_TO_PYTHON_DICT.keys()[0]: self.to_JSON()
-                },
-                'path': path_parameters,
-                'query': {}
-            },
-            'token': token
-        }
-
-    # SQL STATEMENT GENERATION METHODS
-
-    @classmethod
-    def _generate_insert_columns_string(cls):
-        """Generate a SQLite insertion columns string for this Model"""
-
-        return ', '.join(cls.COLUMNS)
-
-    @classmethod
-    def _generate_insert_placeholders_string(cls):
-        """Generate a SQLite insertion placeholders string for this Model."""
-
-        return ', '.join(['%s'] * len(cls.COLUMNS))
-
-    @classmethod
-    def _generate_primary_key_string(cls):
-        """Generate the SQLite primary key string for this Model."""
-
-        return ' AND '.join(['{} = %s'.format(x) for x in cls.COLUMNS_PRIMARY_KEY])
-
-    @classmethod
-    def _generate_update_columns_string(cls):
-        """Generate a SQLite updatable columns string for this Model."""
-
-        return ', '.join(['{} = %s'.format(x) for x in cls.COLUMNS if x not in cls.COLUMNS_PRIMARY_KEY])
-
-    # SQL TUPLE GENERATION METHODS
-
-    def _generate_insert_columns_tuple(self):
-        """Generate the tuple of insertion column values for this object."""
-
-        value_list = []
-
-        for column in self.COLUMNS:
-            value_list.append(getattr(self, column, None))
-
-        return tuple(value_list)
-
-    def _generate_primary_key_tuple(self):
-        """Generate the tuple of primary key values for this object."""
-
-        primary_key_list = []
-
-        for column in self.COLUMNS_PRIMARY_KEY:
-            primary_key_list.append(getattr(self, column, None))
-
-        return tuple(primary_key_list)
-
-    def _generate_update_columns_tuple(self):
-        """Generate the tuple of updatable column values for this object."""
-
-        value_list = []
-
-        for column in [x for x in self.COLUMNS if x not in self.COLUMNS_PRIMARY_KEY]:
-            value_list.append(getattr(self, column, None))
-
-        return tuple(value_list)
-
-    # DATABASE HELPER METHODS
-
-    @classmethod
-    def _from_database(cls, statement, values):
-        """Initialize a Model by fetching it from the database."""
-
-        parameters = {}
-        model_from_database = database.fetch_one(statement, values)
-
-        if model_from_database is None:
-            return None
-
-        for i in range(len(cls.COLUMNS)):
-            parameters[cls.COLUMNS[i]] = model_from_database[i]
-
-        return cls(**parameters)
-
-    # PUBLIC DATABASE INTERACTION METHODS
-
-    @classmethod
-    def from_primary_key(cls, primary_key_tuple):
-        """Initialize a Model by fetching it by its primary key tuple.
-        
-        If the primary key does not exist in the database, return a stub.
-        """
-
-        query = 'SELECT * FROM {} WHERE {}'.format(cls.COLLECTION_NAME, cls._generate_primary_key_string())
-
-        # Return an instantiation of the Model with values from the row if it exists
-
-        model = cls._from_database(query, primary_key_tuple)
-        if model is not None:
-            return model
-
-        # Return a stub instantiation of the Model with just the primary key if it does not
-
-        parameters = {}
-        for i, column in enumerate(cls.COLUMNS_PRIMARY_KEY):
-            parameters[column] = primary_key_tuple[i]
-
-        return cls(**parameters)
-
-    @classmethod
-    def query(cls, column_name=None, value=None):
-        """Return all instances of the Model in the database where column_name = value."""
-
-        if column_name is not None and value is not None:
-            statement = 'SELECT * FROM {} WHERE {} = %s'.format(cls.COLLECTION_NAME, column_name)
-            database_models = database.fetch_all(statement, (value, ))
-
-        else:
-            statement = 'SELECT * FROM {}'.format(cls.COLLECTION_NAME)
-            database_models = database.fetch_all(statement)
-
-        models = []
-
-        for database_model in database_models:
-
-            parameters = {}
-            for i, parameter in enumerate(cls.COLUMNS):
-                parameters[parameter] = database_model[i]
-
-            models.append(cls(**parameters))
-
-        return models
-
-    def delete(self):
-        """Delete this Model from the database."""
-
-        self.read()
-
-        statement = 'DELETE FROM {} WHERE {}'.format(self.COLLECTION_NAME, self._generate_primary_key_string())
-
-        values = self._generate_primary_key_tuple()
-
-        database.execute(statement, values)
-
-    def exists(self, column=None):
-        """Return True if this Model exists in the database.
-        
-        Check the primary key by default, or a column if one is specified.
-        """
-
-        query = """
-            SELECT EXISTS (
-                SELECT 1 FROM {}
-                WHERE {}
-                LIMIT 1
-            )
-        """
-
-        if column is None:
-            query = query.format(self.COLLECTION_NAME, self._generate_primary_key_string())
-            values = self._generate_primary_key_tuple()
-
-        else:
-            query = query.format(self.COLLECTION_NAME, '{} = %s'.format(column))
-            values = (getattr(self, column), )
-
-        return database.fetch_one(query, values)[0] == 1
-
-    def insert(self):
-        """Insert this Model into the database."""
-
-        if hasattr(self, 'id'):
-            self.id = None
-
-        self.insert_with_id()
-
-    def insert_with_id(self, is_auto_generated=True):
-        """Insert this Model into the database without removing its id."""
-
-        statement = 'INSERT INTO {} ({}) VALUES ({})'.format(self.COLLECTION_NAME,
-                                                             self._generate_insert_columns_string(),
-                                                             self._generate_insert_placeholders_string())
-
-        values = self._generate_insert_columns_tuple()
-
-        try:
-            last_row_id = database.execute(statement, values)
-        except Exception as e:
-            print(e)
-            raise exceptions.ForeignKeyError(e)
-
-        if 'id' in self.COLUMNS_PRIMARY_KEY:
-            if is_auto_generated:
-                setattr(self, 'id', last_row_id)
-            self.read()
-
-    def read(self):
-        """Read this Model's non-primary key attributes from the database."""
-
-        if not self.exists():
-            raise exceptions.RowNotFoundError(self.COLLECTION_NAME)
-
-        database_model = self.from_primary_key(self._generate_primary_key_tuple())
-
-        for attribute in self.COLUMNS:
-            setattr(self, attribute, getattr(database_model, attribute))
-
-        return self
-
-    def update(self):
-        """Update this Model's non-primary key attributes in the database."""
-
-        statement = 'UPDATE {} SET {} WHERE {}'.format(self.COLLECTION_NAME, self._generate_update_columns_string(),
-                                                       self._generate_primary_key_string())
-
-        values = self._generate_update_columns_tuple() + self._generate_primary_key_tuple()
-
-        try:
-            database.execute(statement, values)
-        except Exception as e:
-            raise exceptions.ForeignKeyError(e)
diff --git a/web-server/opendc/models_old/object.py b/web-server/opendc/models_old/object.py
deleted file mode 100644
index 8f2e308b..00000000
--- a/web-server/opendc/models_old/object.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Object(Model):
-    JSON_TO_PYTHON_DICT = {'Object': {'id': 'id', 'type': 'type'}}
-
-    COLLECTION_NAME = 'objects'
-    COLUMNS = ['id', 'type']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Tile."""
-
-        return True
diff --git a/web-server/opendc/models_old/path.py b/web-server/opendc/models_old/path.py
deleted file mode 100644
index 4d07b2d5..00000000
--- a/web-server/opendc/models_old/path.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from opendc.models_old.authorization import Authorization
-from opendc.models_old.model import Model
-from opendc.models_old.user import User
-from opendc.util import exceptions
-
-
-class Path(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Path': {
-            'id': 'id',
-            'simulationId': 'simulation_id',
-            'name': 'name',
-            'datetimeCreated': 'datetime_created'
-        }
-    }
-
-    COLLECTION_NAME = 'paths'
-    COLUMNS = ['id', 'simulation_id', 'name', 'datetime_created']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Path."""
-
-        # Get the User id
-
-        try:
-            user_id = User.from_google_id(google_id).read().id
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Authorization
-
-        authorization = Authorization.from_primary_key((user_id, self.simulation_id))
-
-        return authorization.has_at_least(authorization_level)
diff --git a/web-server/opendc/models_old/queued_experiment.py b/web-server/opendc/models_old/queued_experiment.py
deleted file mode 100644
index b474dc31..00000000
--- a/web-server/opendc/models_old/queued_experiment.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class QueuedExperiment(Model):
-    JSON_TO_PYTHON_DICT = {'QueuedExperiment': {'experimentId': 'experiment_id'}}
-
-    COLLECTION_NAME = 'queued_experiments'
-    COLUMNS = ['experiment_id']
-    COLUMNS_PRIMARY_KEY = ['experiment_id']
diff --git a/web-server/opendc/models_old/rack.py b/web-server/opendc/models_old/rack.py
deleted file mode 100644
index dc08eb6a..00000000
--- a/web-server/opendc/models_old/rack.py
+++ /dev/null
@@ -1,61 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.object import Object
-from opendc.models_old.tile import Tile
-
-
-class Rack(Model):
-    JSON_TO_PYTHON_DICT = {
-        'rack': {
-            'id': 'id',
-            'name': 'name',
-            'capacity': 'capacity',
-            'powerCapacityW': 'power_capacity_w',
-            'topologyId': 'topology_id'
-        }
-    }
-
-    PATH = '/v1/tiles/{tileId}/rack'
-
-    COLLECTION_NAME = 'racks'
-    COLUMNS = ['id', 'name', 'capacity', 'power_capacity_w', 'topology_id']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    @classmethod
-    def from_tile_id(cls, tile_id):
-        """Get a Rack from the ID of the Tile it's on."""
-
-        tile = Tile.from_primary_key((tile_id, ))
-
-        if not tile.exists():
-            return Rack(id=-1)
-
-        return cls.from_primary_key((tile.object_id, ))
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Rack."""
-
-        # Get the Tile
-
-        try:
-            tile = Tile.query('object_id', self.id)[0]
-        except:
-            return False
-
-        # Check the Tile's Authorization
-
-        return tile.google_id_has_at_least(google_id, authorization_level)
-
-    def insert(self):
-        """Insert a Rack by first inserting an object."""
-
-        obj = Object(type='RACK')
-        obj.insert()
-
-        self.id = obj.id
-        self.insert_with_id(is_auto_generated=False)
-
-    def delete(self):
-        """Delete a Rack by deleting its associated object."""
-
-        obj = Object.from_primary_key((self.id, ))
-        obj.delete()
diff --git a/web-server/opendc/models_old/rack_state.py b/web-server/opendc/models_old/rack_state.py
deleted file mode 100644
index 12e0f931..00000000
--- a/web-server/opendc/models_old/rack_state.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.util import database
-
-
-class RackState(Model):
-    JSON_TO_PYTHON_DICT = {'RackState': {'rackId': 'rack_id', 'loadFraction': 'load_fraction', 'tick': 'tick'}}
-
-    @classmethod
-    def _from_database_row(cls, row):
-        """Instantiate a RackState from a database row."""
-
-        return cls(rack_id=row[0], load_fraction=row[1], tick=row[2])
-
-    @classmethod
-    def from_experiment_id(cls, experiment_id):
-        """Query RackStates by their Experiment id."""
-
-        rack_states = []
-
-        statement = '''
-            SELECT racks.id, avg(machine_states.load_fraction), machine_states.tick
-            FROM racks
-                JOIN machines ON racks.id = machines.rack_id
-                JOIN machine_states ON machines.id = machine_states.machine_id
-            WHERE machine_states.experiment_id = %s
-            GROUP BY machine_states.tick, racks.id
-        '''
-        results = database.fetch_all(statement, (experiment_id, ))
-
-        for row in results:
-            rack_states.append(cls._from_database_row(row))
-
-        return rack_states
-
-    @classmethod
-    def from_experiment_id_and_tick(cls, experiment_id, tick):
-        """Query RackStates by their Experiment id."""
-
-        rack_states = []
-
-        statement = '''
-            SELECT racks.id, avg(machine_states.load_fraction), machine_states.tick
-            FROM racks
-                JOIN machines ON racks.id = machines.rack_id
-                JOIN machine_states ON machines.id = machine_states.machine_id
-            WHERE machine_states.experiment_id = %s
-                AND machine_states.tick = %s
-            GROUP BY machine_states.tick, racks.id
-        '''
-        results = database.fetch_all(statement, (experiment_id, tick))
-
-        for row in results:
-            rack_states.append(cls._from_database_row(row))
-
-        return rack_states
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this RackState."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/room.py b/web-server/opendc/models_old/room.py
deleted file mode 100644
index e0eb7c2f..00000000
--- a/web-server/opendc/models_old/room.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from opendc.models_old.datacenter import Datacenter
-from opendc.models_old.model import Model
-from opendc.util import exceptions
-
-
-class Room(Model):
-    JSON_TO_PYTHON_DICT = {
-        'room': {
-            'id': 'id',
-            'datacenterId': 'datacenter_id',
-            'name': 'name',
-            'roomType': 'type',
-            'topologyId': 'topology_id'
-        }
-    }
-
-    PATH = '/v1/datacenters/{datacenterId}/rooms'
-
-    COLLECTION_NAME = 'rooms'
-    COLUMNS = ['id', 'name', 'datacenter_id', 'type', 'topology_id']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Room."""
-
-        # Get the Datacenter
-
-        try:
-            datacenter = Datacenter.from_primary_key((self.datacenter_id, ))
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Datacenter's Authorization
-
-        return datacenter.google_id_has_at_least(google_id, authorization_level)
diff --git a/web-server/opendc/models_old/room_state.py b/web-server/opendc/models_old/room_state.py
deleted file mode 100644
index c6635649..00000000
--- a/web-server/opendc/models_old/room_state.py
+++ /dev/null
@@ -1,71 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.util import database
-
-
-class RoomState(Model):
-    JSON_TO_PYTHON_DICT = {'RoomState': {'roomId': 'room_id', 'loadFraction': 'load_fraction', 'tick': 'tick'}}
-
-    @classmethod
-    def _from_database_row(cls, row):
-        """Instantiate a RoomState from a database row."""
-
-        return cls(room_id=row[0], load_fraction=row[1], tick=row[2])
-
-    @classmethod
-    def from_experiment_id(cls, experiment_id):
-        """Query RoomStates by their Experiment id."""
-
-        room_states = []
-
-        statement = '''
-            SELECT rooms.id, avg(machine_states.load_fraction), machine_states.tick
-            FROM rooms
-                JOIN tiles ON rooms.id = tiles.room_id
-                JOIN objects ON tiles.object_id = objects.id
-                JOIN racks ON objects.id = racks.id
-                JOIN machines ON racks.id = machines.rack_id
-                JOIN machine_states ON machines.id = machine_states.machine_id
-            WHERE objects.type = "RACK"
-                AND machine_states.experiment_id = %s
-            GROUP BY machine_states.tick, rooms.id
-        '''
-        results = database.fetch_all(statement, (experiment_id, ))
-
-        for row in results:
-            room_states.append(cls._from_database_row(row))
-
-        return room_states
-
-    @classmethod
-    def from_experiment_id_and_tick(cls, experiment_id, tick):
-        """Query RoomStates by their Experiment id."""
-
-        room_states = []
-
-        statement = '''
-            SELECT rooms.id, avg(machine_states.load_fraction), machine_states.tick
-            FROM rooms
-                JOIN tiles ON rooms.id = tiles.room_id
-                JOIN objects ON tiles.object_id = objects.id
-                JOIN racks ON objects.id = racks.id
-                JOIN machines ON racks.id = machines.rack_id
-                JOIN machine_states ON machines.id = machine_states.machine_id
-            WHERE objects.type = "RACK"
-                AND machine_states.experiment_id = %s
-                AND machine_states.tick = %s
-            GROUP BY rooms.id
-        '''
-        results = database.fetch_all(statement, (experiment_id, tick))
-
-        for row in results:
-            room_states.append(cls._from_database_row(row))
-
-        return room_states
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this RackState."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/room_type.py b/web-server/opendc/models_old/room_type.py
deleted file mode 100644
index 755572f8..00000000
--- a/web-server/opendc/models_old/room_type.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class RoomType(Model):
-    JSON_TO_PYTHON_DICT = {'RoomType': {'name': 'name'}}
-
-    COLLECTION_NAME = 'room_types'
-    COLUMNS = ['name']
-    COLUMNS_PRIMARY_KEY = ['name']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this RoomType."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/scheduler.py b/web-server/opendc/models_old/scheduler.py
deleted file mode 100644
index b9939321..00000000
--- a/web-server/opendc/models_old/scheduler.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Scheduler(Model):
-    JSON_TO_PYTHON_DICT = {'Scheduler': {'name': 'name'}}
-
-    COLLECTION_NAME = 'schedulers'
-    COLUMNS = ['name']
-    COLUMNS_PRIMARY_KEY = ['name']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Scheduler."""
-
-        return authorization_level not in ['EDIT', 'OWN']
diff --git a/web-server/opendc/models_old/section.py b/web-server/opendc/models_old/section.py
deleted file mode 100644
index 0df4967c..00000000
--- a/web-server/opendc/models_old/section.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.path import Path
-from opendc.util import exceptions
-
-
-class Section(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Section': {
-            'id': 'id',
-            'pathId': 'path_id',
-            'datacenterId': 'datacenter_id',
-            'startTick': 'start_tick'
-        }
-    }
-
-    COLLECTION_NAME = 'sections'
-    COLUMNS = ['id', 'path_id', 'datacenter_id', 'start_tick']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Section."""
-
-        # Get the Path
-
-        try:
-            path = Path.from_primary_key((self.path_id, ))
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Path's Authorization
-
-        return path.google_id_has_at_least(google_id, authorization_level)
diff --git a/web-server/opendc/models_old/simulation.py b/web-server/opendc/models_old/simulation.py
deleted file mode 100644
index 9c1820a3..00000000
--- a/web-server/opendc/models_old/simulation.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from opendc.models_old.authorization import Authorization
-from opendc.models_old.model import Model
-from opendc.models_old.user import User
-from opendc.util import exceptions
-
-
-class Simulation(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Simulation': {
-            'id': 'id',
-            'name': 'name',
-            'datetimeCreated': 'datetime_created',
-            'datetimeLastEdited': 'datetime_last_edited'
-        }
-    }
-
-    COLLECTION_NAME = 'simulations'
-    COLUMNS = ['id', 'datetime_created', 'datetime_last_edited', 'name']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Simulation."""
-
-        # Get the User id
-
-        try:
-            user_id = User.from_google_id(google_id).read().id
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Get the Simulation id
-
-        simulation_id = self.id
-
-        # Check the Authorization
-
-        authorization = Authorization.from_primary_key((user_id, simulation_id))
-
-        return authorization.has_at_least(authorization_level)
diff --git a/web-server/opendc/models_old/storage.py b/web-server/opendc/models_old/storage.py
deleted file mode 100644
index 9f0f9215..00000000
--- a/web-server/opendc/models_old/storage.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Storage(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Storage': {
-            'id': 'id',
-            'manufacturer': 'manufacturer',
-            'family': 'family',
-            'generation': 'generation',
-            'model': 'model',
-            'speedMbPerS': 'speed_mb_per_s',
-            'sizeMb': 'size_mb',
-            'energyConsumptionW': 'energy_consumption_w',
-            'failureModelId': 'failure_model_id'
-        }
-    }
-
-    COLLECTION_NAME = 'storages'
-
-    COLUMNS = [
-        'id', 'manufacturer', 'family', 'generation', 'model', 'speed_mb_per_s', 'size_mb', 'energy_consumption_w',
-        'failure_model_id'
-    ]
-
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this Storage."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/task.py b/web-server/opendc/models_old/task.py
deleted file mode 100644
index e6f99014..00000000
--- a/web-server/opendc/models_old/task.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Task(Model):
-    JSON_TO_PYTHON_DICT = {
-        'Task': {
-            'id': 'id',
-            'startTick': 'start_tick',
-            'totalFlopCount': 'total_flop_count',
-            'coreCount': 'core_count',
-            'jobId': 'job_id',
-        }
-    }
-
-    COLLECTION_NAME = 'tasks'
-    COLUMNS = ['id', 'start_tick', 'total_flop_count', 'job_id', 'core_count']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Task."""
-
-        return authorization_level not in ['EDIT', 'OWN']
diff --git a/web-server/opendc/models_old/task_duration.py b/web-server/opendc/models_old/task_duration.py
deleted file mode 100644
index 5058e8de..00000000
--- a/web-server/opendc/models_old/task_duration.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.util import database
-
-
-class TaskDuration(Model):
-    JSON_TO_PYTHON_DICT = {'TaskDuration': {'taskId': 'task_id', 'duration': 'duration'}}
-
-    @classmethod
-    def _from_database_row(cls, row):
-        """Instantiate a RoomState from a database row."""
-
-        return cls(task_id=row[0], duration=row[1])
-
-    @classmethod
-    def from_experiment_id(cls, experiment_id):
-        """Query RoomStates by their Experiment id."""
-
-        room_states = []
-
-        statement = '''
-            SELECT task_id, MAX(tick) - MIN(tick) as duration FROM task_states
-            WHERE experiment_id = %s
-            GROUP BY task_id
-        '''
-
-        results = database.fetch_all(statement, (experiment_id, ))
-
-        for row in results:
-            room_states.append(cls._from_database_row(row))
-
-        return room_states
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this TaskDuration."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/task_state.py b/web-server/opendc/models_old/task_state.py
deleted file mode 100644
index cc3fdd89..00000000
--- a/web-server/opendc/models_old/task_state.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.util import database
-
-
-class TaskState(Model):
-    JSON_TO_PYTHON_DICT = {
-        'TaskState': {
-            'id': 'id',
-            'taskId': 'task_id',
-            'experimentId': 'experiment_id',
-            'tick': 'tick',
-            'flopsLeft': 'flops_left',
-            'coresUsed': 'cores_used'
-        }
-    }
-
-    COLLECTION_NAME = 'task_states'
-
-    COLUMNS = ['id', 'task_id', 'experiment_id', 'tick', 'flops_left', 'cores_used']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    @classmethod
-    def from_experiment_id_and_tick(cls, experiment_id, tick):
-        """Query Task States by their Experiment id and tick."""
-
-        task_states = []
-
-        statement = 'SELECT * FROM task_states WHERE experiment_id = %s AND tick = %s'
-        results = database.fetch_all(statement, (experiment_id, tick))
-
-        for row in results:
-            task_states.append(cls(id=row[0], task_id=row[1], experiment_id=row[2], tick=row[3], flops_left=row[4]))
-
-        return task_states
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this TaskState."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return False
-
-        return True
diff --git a/web-server/opendc/models_old/tile.py b/web-server/opendc/models_old/tile.py
deleted file mode 100644
index e46b29a6..00000000
--- a/web-server/opendc/models_old/tile.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from opendc.models_old.model import Model
-from opendc.models_old.object import Object
-from opendc.models_old.room import Room
-from opendc.util import exceptions
-
-
-class Tile(Model):
-    JSON_TO_PYTHON_DICT = {
-        'tile': {
-            'id': 'id',
-            'roomId': 'room_id',
-            'objectId': 'object_id',
-            'objectType': 'object_type',
-            'positionX': 'position_x',
-            'positionY': 'position_y',
-            'topologyId': 'topology_id'
-        }
-    }
-
-    PATH = '/v1/rooms/{roomId}/tiles'
-
-    COLLECTION_NAME = 'tiles'
-    COLUMNS = ['id', 'position_x', 'position_y', 'room_id', 'object_id', 'topology_id']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Tile."""
-
-        # Get the Room
-
-        try:
-            room = Room.from_primary_key((self.room_id, ))
-        except exceptions.RowNotFoundError:
-            return False
-
-        # Check the Room's Authorization
-
-        return room.google_id_has_at_least(google_id, authorization_level)
-
-    def read(self):
-        """Read this Tile by also getting its associated object type."""
-
-        super(Tile, self).read()
-
-        if self.object_id is not None:
-            obj = Object.from_primary_key((self.object_id, ))
-            self.object_type = obj.type
diff --git a/web-server/opendc/models_old/trace.py b/web-server/opendc/models_old/trace.py
deleted file mode 100644
index 58abe058..00000000
--- a/web-server/opendc/models_old/trace.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class Trace(Model):
-    JSON_TO_PYTHON_DICT = {'Trace': {'id': 'id', 'name': 'name'}}
-
-    COLLECTION_NAME = 'traces'
-    COLUMNS = ['id', 'name']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the user has at least the given auth level over this Trace."""
-
-        return authorization_level not in ['EDIT', 'OWN']
diff --git a/web-server/opendc/models_old/user.py b/web-server/opendc/models_old/user.py
deleted file mode 100644
index 657d5019..00000000
--- a/web-server/opendc/models_old/user.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from opendc.models_old.model import Model
-
-
-class User(Model):
-    JSON_TO_PYTHON_DICT = {
-        'User': {
-            'id': 'id',
-            'googleId': 'google_id',
-            'email': 'email',
-            'givenName': 'given_name',
-            'familyName': 'family_name'
-        }
-    }
-
-    COLLECTION_NAME = 'users'
-    COLUMNS = ['id', 'google_id', 'email', 'given_name', 'family_name']
-    COLUMNS_PRIMARY_KEY = ['id']
-
-    @classmethod
-    def from_google_id(cls, google_id):
-        """Initialize a User by fetching them by their google id."""
-
-        user = cls._from_database('SELECT * FROM users WHERE google_id = %s', (google_id, ))
-
-        if user is not None:
-            return user
-
-        return User()
-
-    @classmethod
-    def from_email(cls, email):
-        """Initialize a User by fetching them by their email."""
-
-        user = cls._from_database('SELECT * FROM users WHERE email = %s', (email, ))
-
-        if user is not None:
-            return user
-
-        return User()
-
-    def google_id_has_at_least(self, google_id, authorization_level):
-        """Return True if the User has at least the given auth level over this User."""
-
-        if authorization_level in ['EDIT', 'OWN']:
-            return google_id == self.google_id
-
-        return True