Initial commit

1 files changed, 1724 insertions, 0 deletions

diff --git a/src/scripts/controllers/connection/api.ts b/src/scripts/controllers/connection/api.ts
new file mode 100644
index 00000000..067e3ca0
--- /dev/null
+++ b/src/scripts/controllers/connection/api.ts
@@ -0,0 +1,1724 @@
+///<reference path="../../definitions.ts" />
+///<reference path="../../../../typings/index.d.ts" />
+import {Util} from "../../util";
+import {ServerConnection} from "../../serverconnection";
+
+
+export class APIController {
+    constructor(onConnect: (api: APIController) => any) {
+        ServerConnection.connect(() => {
+            onConnect(this);
+        });
+    }
+
+
+    ///
+    // PATH: /users
+    ///
+
+    // METHOD: GET
+    public getUserByEmail(email: string): Promise<IUser> {
+        return ServerConnection.send({
+            path: "/users",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {
+                    email
+                }
+            }
+        });
+    }
+
+    // METHOD: POST
+    public addUser(user: IUser): Promise<IUser> {
+        return ServerConnection.send({
+            path: "/users",
+            method: "POST",
+            parameters: {
+                body: {
+                    user: user
+                },
+                path: {},
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /users/{id}
+    ///
+
+    // METHOD: GET
+    public getUser(userId: number): Promise<IUser> {
+        return ServerConnection.send({
+            path: "/users/{userId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    // METHOD: PUT
+    public updateUser(userId: number, user: IUser): Promise<IUser> {
+        return ServerConnection.send({
+            path: "/users/{userId}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    user: {
+                        givenName: user.givenName,
+                        familyName: user.familyName
+                    }
+                },
+                path: {
+                    userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteUser(userId: number): Promise<IUser> {
+        return ServerConnection.send({
+            path: "/users/{userId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /users/{userId}/authorizations
+    ///
+
+    // METHOD: GET
+    public getAuthorizationsByUser(userId: number): Promise<IAuthorization[]> {
+        let authorizations = [];
+        return ServerConnection.send({
+            path: "/users/{userId}/authorizations",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    userId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            authorizations = data;
+            return this.getUser(userId);
+        }).then((userData: any) => {
+            let promises = [];
+            authorizations.forEach((authorization: IAuthorization) => {
+                authorization.user = userData;
+                promises.push(this.getSimulation(authorization.simulationId).then((simulationData: any) => {
+                    authorization.simulation = simulationData;
+                }));
+            });
+            return Promise.all(promises);
+        }).then((data: any) => {
+            return authorizations;
+        });
+    }
+
+    ///
+    // PATH: /simulations
+    ///
+
+    // METHOD: POST
+    public addSimulation(simulation: ISimulation): Promise<ISimulation> {
+        return ServerConnection.send({
+            path: "/simulations",
+            method: "POST",
+            parameters: {
+                body: {
+                    simulation: Util.packageForSending(simulation)
+                },
+                path: {},
+                query: {}
+            }
+        }).then((data: any) => {
+            this.parseSimulationTimestamps(data);
+            return data;
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}
+    ///
+
+    // METHOD: GET
+    public getSimulation(simulationId: number): Promise<ISimulation> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            this.parseSimulationTimestamps(data);
+            return data;
+        });
+    }
+
+    // METHOD: PUT
+    public updateSimulation(simulation: ISimulation): Promise<ISimulation> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    simulation: Util.packageForSending(simulation)
+                },
+                path: {
+                    simulationId: simulation.id
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            this.parseSimulationTimestamps(data);
+            return data;
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteSimulation(simulationId: number): Promise<ISimulation> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/authorizations
+    ///
+
+    // METHOD: GET
+    public getAuthorizationsBySimulation(simulationId: number): Promise<IAuthorization[]> {
+        let authorizations = [];
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/authorizations",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            authorizations = data;
+            return this.getSimulation(simulationId);
+        }).then((simulationData: any) => {
+            let promises = [];
+            authorizations.forEach((authorization: IAuthorization) => {
+                authorization.simulation = simulationData;
+                promises.push(this.getUser(authorization.userId).then((userData: any) => {
+                    authorization.user = userData;
+                }));
+            });
+            return Promise.all(promises);
+        }).then((data: any) => {
+            return authorizations;
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/authorizations/{userId}
+    ///
+
+    // METHOD: GET
+    // Not needed
+
+    // METHOD: POST
+    public addAuthorization(authorization: IAuthorization): Promise<IAuthorization> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/authorizations/{userId}",
+            method: "POST",
+            parameters: {
+                body: {
+                    authorization: {
+                        authorizationLevel: authorization.authorizationLevel
+                    }
+                },
+                path: {
+                    simulationId: authorization.simulationId,
+                    userId: authorization.userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    // METHOD: PUT
+    public updateAuthorization(authorization: IAuthorization): Promise<IAuthorization> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/authorizations/{userId}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    authorization: {
+                        authorizationLevel: authorization.authorizationLevel
+                    }
+                },
+                path: {
+                    simulationId: authorization.simulationId,
+                    userId: authorization.userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteAuthorization(authorization: IAuthorization): Promise<IAuthorization> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/authorizations/{userId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId: authorization.simulationId,
+                    userId: authorization.userId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}
+    ///
+
+    // METHOD: GET
+    public getDatacenter(simulationId: number, datacenterId: number): Promise<IDatacenter> {
+        let datacenter;
+
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            datacenter = data;
+
+            return this.getRoomsByDatacenter(simulationId, datacenterId);
+        }).then((data: any) => {
+            datacenter.rooms = data;
+            return datacenter;
+        });
+    }
+
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms
+    ///
+
+    // METHOD: GET
+    public getRoomsByDatacenter(simulationId: number, datacenterId: number): Promise<IRoom[]> {
+        let rooms;
+
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            rooms = data;
+
+            let promises = [];
+            rooms.forEach((room: IRoom) => {
+                promises.push(this.loadRoomTiles(simulationId, datacenterId, room));
+            });
+            return Promise.all(promises).then((data: any) => {
+                return rooms;
+            });
+        });
+    }
+
+    // METHOD: POST
+    public addRoomToDatacenter(simulationId: number, datacenterId: number): Promise<IRoom> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms",
+            method: "POST",
+            parameters: {
+                body: {
+                    room: {
+                        id: -1,
+                        datacenterId,
+                        roomType: "SERVER"
+                    }
+                },
+                path: {
+                    simulationId,
+                    datacenterId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            data.tiles = [];
+            return data;
+        });
+    }
+
+    ///
+    // PATH: /room-types
+    ///
+
+    // METHOD: GET
+    public getAllRoomTypes(): Promise<string[]> {
+        return ServerConnection.send({
+            path: "/room-types",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        }).then((data: any) => {
+            let result = [];
+            data.forEach((roomType: any) => {
+                result.push(roomType.name);
+            });
+            return result;
+        });
+    }
+
+    ///
+    // PATH: /room-types/{name}/allowed-objects
+    ///
+
+    // METHOD: GET
+    public getAllowedObjectsByRoomType(name: string): Promise<string[]> {
+        return ServerConnection.send({
+            path: "/room-types/{name}/allowed-objects",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    name
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}
+    ///
+
+    // METHOD: GET
+    public getRoom(simulationId: number, datacenterId: number, roomId: number): Promise<IRoom> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadRoomTiles(simulationId, datacenterId, data);
+        });
+    }
+
+    // METHOD: PUT
+    public updateRoom(simulationId: number, datacenterId: number, room: IRoom): Promise<IRoom> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    room: Util.packageForSending(room)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId: room.id
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadRoomTiles(simulationId, datacenterId, data);
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteRoom(simulationId: number, datacenterId: number, roomId: number): Promise<IRoom> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles
+    ///
+
+    // METHOD: GET
+    public getTilesByRoom(simulationId: number, datacenterId: number, roomId: number): Promise<ITile[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((item) => {
+                return this.loadTileObject(simulationId, datacenterId, roomId, item);
+            });
+
+            return Promise.all(promises).then(() => {
+                return data;
+            })
+        });
+    }
+
+    // METHOD: POST
+    public addTileToRoom(simulationId: number, datacenterId: number, roomId: number, tile: ITile): Promise<ITile> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles",
+            method: "POST",
+            parameters: {
+                body: {
+                    tile: Util.packageForSending(tile)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadTileObject(simulationId, datacenterId, roomId, data);
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}
+    ///
+
+    // METHOD: GET
+    // Not needed (yet)
+
+    // METHOD: DELETE
+    public deleteTile(simulationId: number, datacenterId: number, roomId: number, tileId: number): Promise<ITile> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/cooling-item
+    ///
+
+    // METHOD: GET
+    public getCoolingItem(simulationId: number, datacenterId: number, roomId: number,
+                          tileId: number): Promise<ICoolingItem> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/cooling-item",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadFailureModel(data);
+        });
+    }
+
+    // METHOD: POST
+    public addCoolingItem(simulationId: number, datacenterId: number, roomId: number, tileId: number,
+                          coolingItem: ICoolingItem): Promise<ICoolingItem> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/cooling-item",
+            method: "POST",
+            parameters: {
+                body: {
+                    coolingItem: Util.packageForSending(coolingItem)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadFailureModel(data);
+        });
+    }
+
+    // METHOD: PUT
+    // Not needed (yet)
+
+    // METHOD: DELETE
+    public deleteCoolingItem(simulationId: number, datacenterId: number, roomId: number,
+                             tileId: number): Promise<ICoolingItem> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/cooling-item",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/psu
+    ///
+
+    // METHOD: GET
+    public getPSU(simulationId: number, datacenterId: number, roomId: number, tileId: number): Promise<IPSU> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/psu",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadFailureModel(data);
+        });
+    }
+
+    // METHOD: POST
+    public addPSU(simulationId: number, datacenterId: number, roomId: number, tileId: number,
+                  psu: IPSU): Promise<IPSU> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/psu",
+            method: "POST",
+            parameters: {
+                body: {
+                    psu: Util.packageForSending(psu)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadFailureModel(data);
+        });
+    }
+
+    // METHOD: PUT
+    // Not needed (yet)
+
+    // METHOD: DELETE
+    public deletePSU(simulationId: number, datacenterId: number, roomId: number,
+                     tileId: number): Promise<IPSU> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/psu",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack
+    ///
+
+    // METHOD: GET
+    public getRack(simulationId: number, datacenterId: number, roomId: number,
+                   tileId: number): Promise<IRack> {
+        let rack = {};
+
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            rack = data;
+            return this.getMachinesByRack(simulationId, datacenterId, roomId, tileId);
+        }).then((machines: any) => {
+            let promises = machines.map((machine) => {
+                return this.loadMachineUnits(machine);
+            });
+
+
+            return Promise.all(promises).then(() => {
+                rack["machines"] = [];
+
+                machines.forEach((machine: IMachine) => {
+                    rack["machines"][machine.position] = machine;
+                });
+
+                for (let i = 0; i < rack["capacity"]; i++) {
+                    if (rack["machines"][i] === undefined) {
+                        rack["machines"][i] = null;
+                    }
+                }
+
+                return rack;
+            });
+        });
+    }
+
+    // METHOD: POST
+    public addRack(simulationId: number, datacenterId: number, roomId: number,
+                   tileId: number, rack: IRack): Promise<IRack> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack",
+            method: "POST",
+            parameters: {
+                body: {
+                    rack: Util.packageForSending(rack)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            data.machines = [];
+
+            for (let i = 0; i < data.capacity; i++) {
+                data.machines.push(null);
+            }
+
+            return data;
+        });
+    }
+
+    // METHOD: PUT
+    public updateRack(simulationId: number, datacenterId: number, roomId: number,
+                      tileId: number, rack: IRack): Promise<IRack> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack",
+            method: "PUT",
+            parameters: {
+                body: {
+                    rack
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            data.machines = rack.machines;
+
+            return data;
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteRack(simulationId: number, datacenterId: number, roomId: number,
+                      tileId: number): Promise<IRack> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines
+    ///
+
+    // METHOD: GET
+    public getMachinesByRack(simulationId: number, datacenterId: number, roomId: number,
+                             tileId: number): Promise<IMachine[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((machine) => {
+                return this.loadMachineUnits(machine);
+            });
+
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    // METHOD: POST
+    public addMachineToRack(simulationId: number, datacenterId: number, roomId: number,
+                            tileId: number, machine: IMachine): Promise<IMachine> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines",
+            method: "POST",
+            parameters: {
+                body: {
+                    machine: Util.packageForSending(machine)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadMachineUnits(data);
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines/{position}
+    ///
+
+    // METHOD: GET
+    // Not needed (yet)
+
+    // METHOD: PUT
+    public updateMachine(simulationId: number, datacenterId: number, roomId: number,
+                         tileId: number, machine: IMachine): Promise<IMachine> {
+        machine["tags"] = [];
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines/{position}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    machine: Util.packageForSending(machine)
+                },
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId,
+                    position: machine.position
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.loadMachineUnits(data);
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteMachine(simulationId: number, datacenterId: number, roomId: number,
+                         tileId: number, position: number): Promise<any> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines/{position}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    datacenterId,
+                    roomId,
+                    tileId,
+                    position
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments
+    ///
+
+    // METHOD: GET
+    public getExperimentsBySimulation(simulationId: number): Promise<IExperiment[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                return this.getTrace(item.traceId).then((traceData: any) => {
+                    item.trace = traceData;
+                });
+            });
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    // METHOD: POST
+    public addExperimentToSimulation(simulationId: number, experiment: IExperiment): Promise<IExperiment> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments",
+            method: "POST",
+            parameters: {
+                body: {
+                    experiment: Util.packageForSending(experiment)
+                },
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.getTrace(data.traceId).then((traceData: any) => {
+                data.trace = traceData;
+
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}
+    ///
+
+    // METHOD: GET
+    // Not needed (yet)
+
+    // METHOD: PUT
+    public updateExperiment(experiment: IExperiment): Promise<IExperiment> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}",
+            method: "PUT",
+            parameters: {
+                body: {
+                    experiment: Util.packageForSending(experiment)
+                },
+                path: {
+                    experimentId: experiment.id,
+                    simulationId: experiment.simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.getTrace(data.traceId).then((traceData: any) => {
+                data.trace = traceData;
+
+                return data;
+            });
+        });
+    }
+
+    // METHOD: DELETE
+    public deleteExperiment(simulationId: number, experimentId: number): Promise<any> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}",
+            method: "DELETE",
+            parameters: {
+                body: {},
+                path: {
+                    experimentId,
+                    simulationId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}/last-simulated-tick
+    ///
+
+    // METHOD: GET
+    public getLastSimulatedTickByExperiment(simulationId: number, experimentId: number): Promise<number> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}/last-simulated-tick",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    experimentId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return data.lastSimulatedTick;
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}/machine-states
+    ///
+
+    // METHOD: GET
+    public getMachineStatesByTick(simulationId: number, experimentId: number, tick: number,
+                                  machines: {[keys: number]: IMachine}): Promise<IMachineState[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}/machine-states",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    experimentId
+                },
+                query: {
+                    tick
+                }
+            }
+        }).then((data: any) => {
+            data.forEach((item: any) => {
+                item.machine = machines[item.machineId];
+            });
+
+            return data;
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}/rack-states
+    ///
+
+    // METHOD: GET
+    public getRackStatesByTick(simulationId: number, experimentId: number, tick: number,
+                               racks: {[keys: number]: IRack}): Promise<IRackState[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}/rack-states",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    experimentId
+                },
+                query: {
+                    tick
+                }
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                item.rack = racks[item.rackId];
+            });
+
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}/room-states
+    ///
+
+    // METHOD: GET
+    public getRoomStatesByTick(simulationId: number, experimentId: number, tick: number,
+                               rooms: {[keys: number]: IRoom}): Promise<IRoomState[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}/room-states",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    experimentId
+                },
+                query: {
+                    tick
+                }
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                item.room = rooms[item.roomId];
+            });
+
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/experiments/{experimentId}/task-states
+    ///
+
+    // METHOD: GET
+    public getTaskStatesByTick(simulationId: number, experimentId: number, tick: number,
+                               tasks: {[keys: number]: ITask}): Promise<ITaskState[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/experiments/{experimentId}/task-states",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    experimentId
+                },
+                query: {
+                    tick
+                }
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                item.task = tasks[item.taskId];
+            });
+
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/paths
+    ///
+
+    // METHOD: GET
+    public getPathsBySimulation(simulationId: number): Promise<IPath[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                return this.getSectionsByPath(simulationId, item.id).then((sectionsData: any) => {
+                    item.sections = sectionsData;
+                });
+            });
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/paths/{pathId}
+    ///
+
+    // METHOD: GET
+    public getPath(simulationId: number, pathId: number): Promise<IPath> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths/{pathId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    pathId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.getSectionsByPath(simulationId, pathId).then((sectionsData: any) => {
+                data.sections = sectionsData;
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/paths/{pathId}/branches
+    ///
+
+    // METHOD: GET
+    public getBranchesByPath(simulationId: number, pathId: number): Promise<IPath[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths/{pathId}/branches",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    pathId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((item: any) => {
+                return this.getSectionsByPath(simulationId, item.id).then((sectionsData: any) => {
+                    item.sections = sectionsData;
+                });
+            });
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    // METHOD: POST
+    public branchFromPath(simulationId: number, pathId: number, startTick: number): Promise<IPath> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths/{pathId}/branches",
+            method: "POST",
+            parameters: {
+                body: {
+                    section: {
+                        startTick
+                    }
+                },
+                path: {
+                    simulationId,
+                    pathId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.getSectionsByPath(simulationId, data.id).then((sectionsData: any) => {
+                data.sections = sectionsData;
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/paths/{pathId}/sections
+    ///
+
+    // METHOD: GET
+    public getSectionsByPath(simulationId: number, pathId: number): Promise<IPath[]> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths/{pathId}/sections",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    pathId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            let promises = data.map((path: ISection) => {
+                return this.getDatacenter(simulationId, path.datacenterId).then((datacenter: any) => {
+                    path.datacenter = datacenter;
+                });
+            });
+            return Promise.all(promises).then(() => {
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /simulations/{simulationId}/paths/{pathId}/sections/{sectionId}
+    ///
+
+    // METHOD: GET
+    public getSection(simulationId: number, pathId: number, sectionId: number): Promise<ISection> {
+        return ServerConnection.send({
+            path: "/simulations/{simulationId}/paths/{pathId}/sections/{sectionId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    simulationId,
+                    pathId,
+                    sectionId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            return this.getDatacenter(simulationId, data.datacenterId).then((datacenter: any) => {
+                data.datacenter = datacenter;
+                return data;
+            });
+        });
+    }
+
+    ///
+    // PATH: /specifications/psus
+    ///
+
+    // METHOD: GET
+    public getAllPSUSpecs(): Promise<IPSU[]> {
+        let psus;
+        return ServerConnection.send({
+            path: "/specifications/psus",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        }).then((data: any) => {
+            psus = data;
+
+            let promises = [];
+            data.forEach((psu: IPSU) => {
+                promises.push(this.getFailureModel(psu.failureModelId));
+            });
+            return Promise.all(promises);
+        }).then((data: any) => {
+            return psus;
+        });
+    }
+
+    ///
+    // PATH: /specifications/psus/{id}
+    ///
+
+    // METHOD: GET
+    public getPSUSpec(id: number): Promise<IPSU> {
+        let psu;
+
+        return ServerConnection.send({
+            path: "/specifications/psus/{id}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    id
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            psu = data;
+            return this.getFailureModel(data.failureModelId);
+        }).then((data: any) => {
+            psu.failureModel = data;
+            return psu;
+        });
+    }
+
+    ///
+    // PATH: /specifications/cooling-items
+    ///
+
+    // METHOD: GET
+    public getAllCoolingItemSpecs(): Promise<ICoolingItem[]> {
+        let coolingItems;
+
+        return ServerConnection.send({
+            path: "/specifications/cooling-items",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        }).then((data: any) => {
+            coolingItems = data;
+
+            let promises = [];
+            data.forEach((item: ICoolingItem) => {
+                promises.push(this.getFailureModel(item.failureModelId));
+            });
+            return Promise.all(promises);
+        }).then((data: any) => {
+            return coolingItems;
+        });
+    }
+
+    ///
+    // PATH: /specifications/cooling-items/{id}
+    ///
+
+    // METHOD: GET
+    public getCoolingItemSpec(id: number): Promise<IPSU> {
+        let coolingItem;
+
+        return ServerConnection.send({
+            path: "/specifications/cooling-items/{id}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    id
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            coolingItem = data;
+            return this.getFailureModel(data.failureModelId);
+        }).then((data: any) => {
+            coolingItem.failureModel = data;
+            return coolingItem;
+        });
+    }
+
+    ///
+    // PATH: /schedulers
+    ///
+
+    // METHOD: GET
+    public getAllSchedulers(): Promise<IScheduler[]> {
+        return ServerConnection.send({
+            path: "/schedulers",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /traces
+    ///
+
+    // METHOD: GET
+    public getAllTraces(): Promise<ITrace[]> {
+        return ServerConnection.send({
+            path: "/traces",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /traces/{traceId}
+    ///
+
+    // METHOD: GET
+    public getTrace(traceId: number): Promise<ITrace> {
+        let trace;
+
+        return ServerConnection.send({
+            path: "/traces/{traceId}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    traceId
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            trace = data;
+            return this.getTasksByTrace(traceId);
+        }).then((data: any) => {
+            trace.tasks = data;
+            return trace;
+        });
+    }
+
+    ///
+    // PATH: /traces/{traceId}/tasks
+    ///
+
+    // METHOD: GET
+    public getTasksByTrace(traceId: number): Promise<ITask[]> {
+        return ServerConnection.send({
+            path: "/traces/{traceId}/tasks",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    traceId
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /specifications/failure-models
+    ///
+
+    // METHOD: GET
+    public getAllFailureModels(): Promise<IFailureModel[]> {
+        return ServerConnection.send({
+            path: "/specifications/failure-models",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /specifications/failure-models/{id}
+    ///
+
+    // METHOD: GET
+    public getFailureModel(id: number): Promise<IFailureModel> {
+        return ServerConnection.send({
+            path: "/specifications/failure-models/{id}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    id
+                },
+                query: {}
+            }
+        });
+    }
+
+    ///
+    // PATH: /specifications/[units]
+    ///
+
+    // METHOD: GET
+    public getAllSpecificationsOfType(typePlural: string): Promise<INodeUnit> {
+        let specs: any;
+        return ServerConnection.send({
+            path: "/specifications/" + typePlural,
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {},
+                query: {}
+            }
+        }).then((data: any) => {
+            specs = data;
+
+            let promises = [];
+            data.forEach((unit: INodeUnit) => {
+                promises.push(this.getFailureModel(unit.failureModelId));
+            });
+            return Promise.all(promises);
+        }).then((data: any) => {
+            return specs;
+        });
+    }
+
+    ///
+    // PATH: /specifications/[units]/{id}
+    ///
+
+    // METHOD: GET
+    public getSpecificationOfType(typePlural: string, id: number): Promise<INodeUnit> {
+        let spec;
+
+        return ServerConnection.send({
+            path: "/specifications/" + typePlural + "/{id}",
+            method: "GET",
+            parameters: {
+                body: {},
+                path: {
+                    id
+                },
+                query: {}
+            }
+        }).then((data: any) => {
+            spec = data;
+            return this.getFailureModel(data.failureModelId);
+        }).then((data: any) => {
+            spec.failureModel = data;
+            return spec;
+        });
+    }
+
+
+    ///
+    // HELPER METHODS
+    ///
+
+    private loadRoomTiles(simulationId: number, datacenterId: number, room: IRoom): Promise<IRoom> {
+        return this.getTilesByRoom(simulationId, datacenterId, room.id).then((data: any) => {
+            room.tiles = data;
+            return room;
+        });
+    }
+
+    private loadTileObject(simulationId: number, datacenterId: number, roomId: number, tile: ITile): Promise<ITile> {
+        let promise;
+
+        switch (tile.objectType) {
+            case "RACK":
+                promise = this.getRack(simulationId, datacenterId, roomId, tile.id).then((data: IRack) => {
+                    tile.object = data;
+                });
+                break;
+            case "PSU":
+                promise = this.getPSU(simulationId, datacenterId, roomId, tile.id).then((data: IPSU) => {
+                    tile.object = data;
+                });
+                break;
+            case "COOLING_ITEM":
+                promise = this.getCoolingItem(simulationId, datacenterId, roomId, tile.id).then((data: ICoolingItem) => {
+                    tile.object = data;
+                });
+                break;
+            default:
+                promise = new Promise((resolve, reject) => {
+                    resolve(undefined);
+                });
+        }
+
+        return promise.then(() => {
+            return tile;
+        })
+    }
+
+    private parseSimulationTimestamps(simulation: ISimulation): void {
+        simulation.datetimeCreatedParsed = Util.parseDateTime(simulation.datetimeCreated);
+        simulation.datetimeLastEditedParsed = Util.parseDateTime(simulation.datetimeLastEdited);
+    }
+
+    private loadFailureModel(data: any): Promise<any> {
+        return this.getFailureModel(data.failureModelId).then((failureModel: IFailureModel) => {
+            data.failureModel = failureModel;
+            return data;
+        });
+    }
+
+    private loadUnitsOfType(idListName: string, objectListName: string, machine: IMachine): Promise<IMachine> {
+        machine[objectListName] = [];
+
+        let promises = machine[idListName].map((item) => {
+            return this.getSpecificationOfType(objectListName, item).then((data) => {
+                machine[objectListName].push(data);
+            });
+        });
+
+        return Promise.all(promises).then(() => {
+            return machine;
+        })
+    }
+
+    private loadMachineUnits(machine: IMachine): Promise<IMachine> {
+        let listNames = [
+            {
+                idListName: "cpuIds",
+                objectListName: "cpus"
+            }, {
+                idListName: "gpuIds",
+                objectListName: "gpus"
+            }, {
+                idListName: "memoryIds",
+                objectListName: "memories"
+            }, {
+                idListName: "storageIds",
+                objectListName: "storages"
+            }
+        ];
+
+        let promises = listNames.map((item: any) => {
+            return this.loadUnitsOfType(item.idListName, item.objectListName, machine);
+        });
+
+        return Promise.all(promises).then(() => {
+            return machine;
+        });
+    }
+}
\ No newline at end of file