diff --git a/server/api/fleet.go b/server/api/fleet.go
new file mode 100644
index 0000000..4674d34
--- /dev/null
+++ b/server/api/fleet.go
@@ -0,0 +1,62 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+
+	"git.nemunai.re/filicop/server/models"
+
+	"github.com/julienschmidt/httprouter"
+)
+
+func init() {
+	router.GET("/fleets/", apiHandler(func (_ httprouter.Params, body []byte) (interface{}, error) {
+		return filicop.GetFleets()
+	}))
+	router.POST("/fleets/", apiHandler(newFleet))
+	router.DELETE("/fleets/", apiHandler(func (_ httprouter.Params, _ []byte) (interface{}, error) {
+		return filicop.ClearFleets()
+	}))
+
+	router.GET("/fleets/:fid", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet, nil
+	})))
+	router.PUT("/fleets/:fid", apiHandler(fleetHandler(updateFleet)))
+	router.DELETE("/fleets/:fid", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet.Delete()
+	})))
+}
+
+func fleetHandler(f func(filicop.Fleet, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		if fid, err := strconv.ParseInt(string(ps.ByName("fid")), 10, 64); err != nil {
+			return nil, err
+		} else if fleet, err := filicop.GetFleet(fid); err != nil {
+			return nil, err
+		} else {
+			return f(fleet, body)
+		}
+	}
+}
+
+func parseFleetJSON(body []byte, next func (filicop.Fleet) (filicop.Fleet, error)) (filicop.Fleet, error) {
+	var uf filicop.Fleet
+	if err := json.Unmarshal(body, &uf); err != nil {
+		return uf, err
+	}
+
+	if len(uf.Label) == 0 {
+		return uf, errors.New("Fleet's label cannot be empty")
+	}
+
+	return next(uf)
+}
+
+func newFleet(_ httprouter.Params, body []byte) (interface{}, error) {
+	return parseFleetJSON(body, filicop.NewFleet)
+}
+
+func updateFleet(fleet filicop.Fleet, body []byte) (interface{}, error) {
+	return parseFleetJSON(body, fleet.Update)
+}
diff --git a/server/api/mission.go b/server/api/mission.go
new file mode 100644
index 0000000..396ad91
--- /dev/null
+++ b/server/api/mission.go
@@ -0,0 +1,118 @@
+package api
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"git.nemunai.re/filicop/server/models"
+
+	"github.com/julienschmidt/httprouter"
+)
+
+func init() {
+	router.GET("/missions/", apiHandler(func (_ httprouter.Params, body []byte) (interface{}, error) {
+		return filicop.GetMissions()
+	}))
+	router.DELETE("/missions/", apiHandler(func (_ httprouter.Params, _ []byte) (interface{}, error) {
+		return filicop.ClearMissions()
+	}))
+
+	router.GET("/missions/:mid", apiHandler(missionHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission, nil
+	})))
+	router.PUT("/missions/:mid", apiHandler(missionHandler(updateMission)))
+	router.DELETE("/missions/:mid", apiHandler(missionHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission.Delete()
+	})))
+
+	// Routes inside a requestor
+	router.GET("/requestors/:rid/missions/", apiHandler(requestorHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.GetMissions()
+	})))
+	router.POST("/requestors/:rid/missions/", apiHandler(requestorHandler(newMission)))
+	router.DELETE("/requestors/:rid/mission/", apiHandler(requestorHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.ClearMissions()
+	})))
+
+	router.GET("/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission, nil
+	})))
+	router.PUT("/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorHandler(updateMission)))
+	router.DELETE("/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission.Delete()
+	})))
+
+	// Routes inside a requestor inside a fleet
+	router.GET("/fleet/:fid/requestors/:rid/missions/", apiHandler(requestorInFleetHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.GetMissions()
+	})))
+	router.POST("/fleet/:fid/requestors/:rid/missions/", apiHandler(requestorInFleetHandler(newMission)))
+	router.DELETE("/fleet/:fid/requestors/:rid/mission/", apiHandler(requestorInFleetHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.ClearMissions()
+	})))
+
+	router.GET("/fleet/:fid/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorInFleetHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission, nil
+	})))
+	router.PUT("/fleet/:fid/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorInFleetHandler(updateMission)))
+	router.DELETE("/fleet/:fid/requestors/:rid/missions/:mid/", apiHandler(missionInRequestorInFleetHandler(func (mission filicop.Mission, _ []byte) (interface{}, error) {
+		return mission.Delete()
+	})))
+}
+
+func missionHandler(f func(filicop.Mission, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		if rid, err := strconv.ParseInt(string(ps.ByName("rid")), 10, 64); err != nil {
+			return nil, err
+		} else if mission, err := filicop.GetMission(rid); err != nil {
+			return nil, err
+		} else {
+			return f(mission, body)
+		}
+	}
+}
+
+func missionInRequestorHandler(f func(filicop.Mission, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		return requestorHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+			if vid, err := strconv.ParseInt(string(ps.ByName("vid")), 10, 64); err != nil {
+				return nil, err
+			} else if mission, err := requestor.GetMission(vid); err != nil {
+				return nil, err
+			} else {
+				return f(mission, body)
+			}
+		})(ps, body)
+	}
+}
+
+func missionInRequestorInFleetHandler(f func(filicop.Mission, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		return requestorInFleetHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+			if vid, err := strconv.ParseInt(string(ps.ByName("vid")), 10, 64); err != nil {
+				return nil, err
+			} else if mission, err := requestor.GetMission(vid); err != nil {
+				return nil, err
+			} else {
+				return f(mission, body)
+			}
+		})(ps, body)
+	}
+}
+
+func parseMissionJSON(body []byte, next func (filicop.Mission) (filicop.Mission, error)) (filicop.Mission, error) {
+	var um filicop.Mission
+	if err := json.Unmarshal(body, &um); err != nil {
+		return um, err
+	}
+
+	return next(um)
+}
+
+func newMission(requestor filicop.Requestor, body []byte) (interface{}, error) {
+	return parseMissionJSON(body, requestor.NewMission)
+}
+
+func updateMission(mission filicop.Mission, body []byte) (interface{}, error) {
+	return parseMissionJSON(body, mission.Update)
+}
diff --git a/server/api/requestor.go b/server/api/requestor.go
new file mode 100644
index 0000000..3b40f77
--- /dev/null
+++ b/server/api/requestor.go
@@ -0,0 +1,92 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+
+	"git.nemunai.re/filicop/server/models"
+
+	"github.com/julienschmidt/httprouter"
+)
+
+func init() {
+	router.GET("/requestors/", apiHandler(func (_ httprouter.Params, body []byte) (interface{}, error) {
+		return filicop.GetRequestors()
+	}))
+	router.DELETE("/requestors/", apiHandler(func (_ httprouter.Params, _ []byte) (interface{}, error) {
+		return filicop.ClearRequestors()
+	}))
+
+	router.GET("/requestors/:rid", apiHandler(requestorHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor, nil
+	})))
+	router.PUT("/requestors/:rid", apiHandler(requestorHandler(updateRequestor)))
+	router.DELETE("/requestors/:rid", apiHandler(requestorHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.Delete()
+	})))
+
+	// Routes inside a fleet
+	router.GET("/fleets/:fid/requestors/", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet.GetRequestors()
+	})))
+	router.POST("/fleets/:fid/requestors/", apiHandler(fleetHandler(newRequestor)))
+	router.DELETE("/fleets/:fid/requestor/", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet.ClearRequestors()
+	})))
+
+	router.GET("/fleets/:fid/requestors/:rid/", apiHandler(requestorInFleetHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor, nil
+	})))
+	router.PUT("/fleets/:fid/requestors/:rid/", apiHandler(requestorInFleetHandler(updateRequestor)))
+	router.DELETE("/fleets/:fid/requestors/:rid/", apiHandler(requestorInFleetHandler(func (requestor filicop.Requestor, _ []byte) (interface{}, error) {
+		return requestor.Delete()
+	})))
+}
+
+func requestorHandler(f func(filicop.Requestor, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		if rid, err := strconv.ParseInt(string(ps.ByName("rid")), 10, 64); err != nil {
+			return nil, err
+		} else if requestor, err := filicop.GetRequestor(rid); err != nil {
+			return nil, err
+		} else {
+			return f(requestor, body)
+		}
+	}
+}
+
+func requestorInFleetHandler(f func(filicop.Requestor, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		return fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+			if vid, err := strconv.ParseInt(string(ps.ByName("vid")), 10, 64); err != nil {
+				return nil, err
+			} else if requestor, err := fleet.GetRequestor(vid); err != nil {
+				return nil, err
+			} else {
+				return f(requestor, body)
+			}
+		})(ps, body)
+	}
+}
+
+func parseRequestorJSON(body []byte, next func (filicop.Requestor) (filicop.Requestor, error)) (filicop.Requestor, error) {
+	var ur filicop.Requestor
+	if err := json.Unmarshal(body, &ur); err != nil {
+		return ur, err
+	}
+
+	if len(ur.Name) == 0 {
+		return ur, errors.New("Requestor's name cannot be empty")
+	}
+
+	return next(ur)
+}
+
+func newRequestor(fleet filicop.Fleet, body []byte) (interface{}, error) {
+	return parseRequestorJSON(body, fleet.NewRequestor)
+}
+
+func updateRequestor(requestor filicop.Requestor, body []byte) (interface{}, error) {
+	return parseRequestorJSON(body, requestor.Update)
+}
diff --git a/server/api/vehicle.go b/server/api/vehicle.go
new file mode 100644
index 0000000..307e21f
--- /dev/null
+++ b/server/api/vehicle.go
@@ -0,0 +1,92 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+
+	"git.nemunai.re/filicop/server/models"
+
+	"github.com/julienschmidt/httprouter"
+)
+
+func init() {
+	router.GET("/vehicles/", apiHandler(func (_ httprouter.Params, body []byte) (interface{}, error) {
+		return filicop.GetVehicles()
+	}))
+	router.DELETE("/vehicles/", apiHandler(func (_ httprouter.Params, _ []byte) (interface{}, error) {
+		return filicop.ClearVehicles()
+	}))
+
+	router.GET("/vehicles/:vid/", apiHandler(vehicleHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle, nil
+	})))
+	router.PUT("/vehicles/:vid/", apiHandler(vehicleHandler(updateVehicle)))
+	router.DELETE("/vehicles/:vid/", apiHandler(vehicleHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.Delete()
+	})))
+
+	// Routes inside a fleet
+	router.GET("/fleets/:fid/vehicles/", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet.GetVehicles()
+	})))
+	router.POST("/fleets/:fid/vehicles/", apiHandler(fleetHandler(newVehicle)))
+	router.DELETE("/fleets/:fid/vehicle/", apiHandler(fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+		return fleet.ClearVehicles()
+	})))
+
+	router.GET("/fleets/:fid/vehicles/:vid/", apiHandler(vehicleInFleetHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle, nil
+	})))
+	router.PUT("/fleets/:fid/vehicles/:vid/", apiHandler(vehicleInFleetHandler(updateVehicle)))
+	router.DELETE("/fleets/:fid/vehicles/:vid/", apiHandler(vehicleInFleetHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.Delete()
+	})))
+}
+
+func vehicleHandler(f func(filicop.Vehicle, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		if vid, err := strconv.ParseInt(string(ps.ByName("vid")), 10, 64); err != nil {
+			return nil, err
+		} else if vehicle, err := filicop.GetVehicle(vid); err != nil {
+			return nil, err
+		} else {
+			return f(vehicle, body)
+		}
+	}
+}
+
+func vehicleInFleetHandler(f func(filicop.Vehicle, []byte) (interface{}, error)) func(httprouter.Params, []byte) (interface{}, error) {
+	return func(ps httprouter.Params, body []byte) (interface{}, error) {
+		return fleetHandler(func (fleet filicop.Fleet, _ []byte) (interface{}, error) {
+			if vid, err := strconv.ParseInt(string(ps.ByName("vid")), 10, 64); err != nil {
+				return nil, err
+			} else if vehicle, err := fleet.GetVehicle(vid); err != nil {
+				return nil, err
+			} else {
+				return f(vehicle, body)
+			}
+		})(ps, body)
+	}
+}
+
+func parseVehicleJSON(body []byte, next func (filicop.Vehicle) (filicop.Vehicle, error)) (filicop.Vehicle, error) {
+	var uv filicop.Vehicle
+	if err := json.Unmarshal(body, &uv); err != nil {
+		return uv, err
+	}
+
+	if len(uv.Label) == 0 {
+		return uv, errors.New("Vehicle's label cannot be empty")
+	}
+
+	return next(uv)
+}
+
+func newVehicle(fleet filicop.Fleet, body []byte) (interface{}, error) {
+	return parseVehicleJSON(body, fleet.NewVehicle)
+}
+
+func updateVehicle(vehicle filicop.Vehicle, body []byte) (interface{}, error) {
+	return parseVehicleJSON(body, vehicle.Update)
+}
diff --git a/server/api/vehicle_location.go b/server/api/vehicle_location.go
new file mode 100644
index 0000000..1638641
--- /dev/null
+++ b/server/api/vehicle_location.go
@@ -0,0 +1,43 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+
+	"git.nemunai.re/filicop/server/models"
+)
+
+func init() {
+	router.GET("/vehicles/:vid/locations/", apiHandler(vehicleHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.GetLocations()
+	})))
+	router.POST("/vehicles/:vid/locations/", apiHandler(vehicleHandler(addVehicleLocation)))
+	router.DELETE("/vehicles/:vid/locations/", apiHandler(vehicleHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.ClearVehicleLocations()
+	})))
+
+	router.GET("/fleet/:fid/vehicles/:vid/locations/", apiHandler(vehicleInFleetHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.GetLocations()
+	})))
+	router.POST("/fleet/:fid/vehicles/:vid/locations/", apiHandler(vehicleInFleetHandler(addVehicleLocation)))
+	router.DELETE("/fleet/:fid/vehicles/:vid/locations/", apiHandler(vehicleInFleetHandler(func (vehicle filicop.Vehicle, _ []byte) (interface{}, error) {
+		return vehicle.ClearVehicleLocations()
+	})))
+}
+
+func parseVehicleLocationJSON(body []byte, next func (filicop.Point) (filicop.VehicleLocation, error)) (filicop.VehicleLocation, error) {
+	var up filicop.Point
+	if err := json.Unmarshal(body, &up); err != nil {
+		return filicop.VehicleLocation{}, err
+	}
+
+	if up.X == 0 || up.Y == 0 {
+		return filicop.VehicleLocation{}, errors.New("Vehicle's coordinates are invalid")
+	}
+
+	return next(up)
+}
+
+func addVehicleLocation(vehicle filicop.Vehicle, body []byte) (interface{}, error) {
+	return parseVehicleLocationJSON(body, vehicle.NewLocation)
+}
diff --git a/server/models/fleet.go b/server/models/fleet.go
index 95b8d88..995033b 100644
--- a/server/models/fleet.go
+++ b/server/models/fleet.go
@@ -33,24 +33,21 @@ func GetFleet(id int64) (f Fleet, err error) {
 	return
 }
 
-func NewFleet(label string) (Fleet, error) {
-	if res, err := DBExec("INSERT INTO fleets (label) VALUES (?)", label); err != nil {
-		return Fleet{}, err
+func NewFleet(f Fleet) (Fleet, error) {
+	if res, err := DBExec("INSERT INTO fleets (label) VALUES (?)", f.Label); err != nil {
+		return f, err
 	} else if fid, err := res.LastInsertId(); err != nil {
-		return Fleet{}, err
+		return f, err
 	} else {
-		return Fleet{fid, label}, nil
+		f.Id = fid
+		return f, nil
 	}
 }
 
-func (f Fleet) Update() (int64, error) {
-	if res, err := DBExec("UPDATE fleets SET label = ? WHERE id_fleet = ?", f.Label, f.Id); err != nil {
-		return 0, err
-	} else if nb, err := res.RowsAffected(); err != nil {
-		return 0, err
-	} else {
-		return nb, err
-	}
+func (f Fleet) Update(uf Fleet) (Fleet, error) {
+	_, err := DBExec("UPDATE fleets SET label = ? WHERE id_fleet = ?", uf.Label, f.Id)
+	uf.Id = f.Id
+	return uf, err
 }
 
 func (f Fleet) Delete() (int64, error) {
diff --git a/server/models/mission.go b/server/models/mission.go
index 9959a76..c9def0f 100644
--- a/server/models/mission.go
+++ b/server/models/mission.go
@@ -1,6 +1,8 @@
 package filicop
 
 import (
+	"errors"
+	"fmt"
 	"time"
 )
 
@@ -35,33 +37,56 @@ func GetMissions() (missions []Mission, err error) {
 }
 
 func GetMission(id int64) (m Mission, err error) {
-	err = DBQueryRow("SELECT id_mission, id_requestor, id_vehicle, creation, location_source,location_destination FROM missions WHERE id_mission = ?", id).Scan(&m.Id, &m.IdRequestor, &m.IdVehicle, &m.Creation, &m.LocationFrom, &m.LocationTo)
+	err = DBQueryRow("SELECT id_mission, id_requestor, id_vehicle, creation, location_source,location_destination FROM missions WHERE id_requestor = ?", id).Scan(&m.Id, &m.IdRequestor, &m.IdVehicle, &m.Creation, &m.LocationFrom, &m.LocationTo)
 	return
 }
 
-func (r Requestor) NewMission(from Point, to Point, vehicle *Vehicle) (Mission, error) {
-	var vid *int64 = nil
-	if vehicle != nil {
-		vid = &vehicle.Id
+func (r Requestor) GetMissions() (missions []Mission, err error) {
+	if rows, errr := DBQuery("SELECT id_mission, id_requestor, id_vehicle, creation, location_source, location_destination FROM missions WHERE id_requestor = ?", r.Id); errr != nil {
+		return nil, errr
+	} else {
+		defer rows.Close()
+
+		for rows.Next() {
+			var m Mission
+			if err = rows.Scan(&m.Id, &m.IdRequestor, &m.IdVehicle, &m.Creation, &m.LocationFrom, &m.LocationTo); err != nil {
+				return
+			}
+			missions = append(missions, m)
+		}
+		if err = rows.Err(); err != nil {
+			return
+		}
+
+		return
+	}
+}
+
+func (r Requestor) GetMission(id int64) (m Mission, err error) {
+	err = DBQueryRow("SELECT id_mission, id_requestor, id_vehicle, creation, location_source,location_destination FROM missions WHERE id_mission = ? AND id_requestor = ?", id, r.Id).Scan(&m.Id, &m.IdRequestor, &m.IdVehicle, &m.Creation, &m.LocationFrom, &m.LocationTo)
+	return
+}
+
+func (r Requestor) NewMission(m Mission) (Mission, error) {
+	if m.IdRequestor != 0 && m.IdRequestor != r.Id {
+		return m, errors.New(fmt.Sprintf("Requestor ID is %d, but try to add mission as requestor %d.", m.IdRequestor, r.Id))
 	}
 
-	if res, err := DBExec("INSERT INTO missions (id_requestor, id_vehicle, location_source, location_destination) VALUES (?, ?, ?, ?)", r.Id, vid, from, to); err != nil {
+	if res, err := DBExec("INSERT INTO missions (id_requestor, id_vehicle, location_source, location_destination) VALUES (?, ?, ?, ?)", r.Id, m.IdVehicle, m.LocationFrom, m.LocationTo); err != nil {
 		return Mission{}, err
 	} else if mid, err := res.LastInsertId(); err != nil {
 		return Mission{}, err
 	} else {
-		return Mission{mid, r.Id, vid, time.Now(), from, to}, nil
+		m.Id = mid
+		m.Creation = time.Now()
+		return m, nil
 	}
 }
 
-func (m Mission) Update() (int64, error) {
-	if res, err := DBExec("UPDATE missions SET id_requestor = ?, creation = ?, location_source = ?, location_destination = ? WHERE id_mission = ?", m.IdRequestor, m.Creation, m.LocationFrom, m.LocationTo, m.Id); err != nil {
-		return 0, err
-	} else if nb, err := res.RowsAffected(); err != nil {
-		return 0, err
-	} else {
-		return nb, err
-	}
+func (m Mission) Update(um Mission) (Mission, error) {
+	_, err := DBExec("UPDATE missions SET id_requestor = ?, creation = ?, location_source = ?, location_destination = ? WHERE id_mission = ?", um.IdRequestor, um.Creation, um.LocationFrom, um.LocationTo, m.Id)
+	um.Id = m.Id
+	return um, err
 }
 
 func (m Mission) Delete() (int64, error) {
diff --git a/server/models/requestor.go b/server/models/requestor.go
index 4a44e48..b5f3be6 100644
--- a/server/models/requestor.go
+++ b/server/models/requestor.go
@@ -34,24 +34,48 @@ func GetRequestor(id int64) (r Requestor, err error) {
 	return
 }
 
-func (f Fleet) NewRequestor(name string) (Requestor, error) {
-	if res, err := DBExec("INSERT INTO requestors (id_fleet, name) VALUES (?, ?)", f.Id, name); err != nil {
+func (f Fleet) GetRequestors() (requestors []Requestor, err error) {
+	if rows, errr := DBQuery("SELECT id_requestor, id_fleet, name FROM requestors WHERE id_fleet = ?", f.Id); errr != nil {
+		return nil, errr
+	} else {
+		defer rows.Close()
+
+		for rows.Next() {
+			var r Requestor
+			if err = rows.Scan(&r.Id, &r.IdFleet, &r.Name); err != nil {
+				return
+			}
+			requestors = append(requestors, r)
+		}
+		if err = rows.Err(); err != nil {
+			return
+		}
+
+		return
+	}
+}
+
+func (f Fleet) GetRequestor(id int64) (r Requestor, err error) {
+	err = DBQueryRow("SELECT id_requestor, id_fleet, name FROM requestors WHERE id_fleet = ? AND id_requestor = ?", f.Id, id).Scan(&r.Id, &r.IdFleet, &r.Name)
+	return
+}
+
+func (f Fleet) NewRequestor(r Requestor) (Requestor, error) {
+	if res, err := DBExec("INSERT INTO requestors (id_fleet, name) VALUES (?, ?)", f.Id, r.Name); err != nil {
 		return Requestor{}, err
 	} else if rid, err := res.LastInsertId(); err != nil {
 		return Requestor{}, err
 	} else {
-		return Requestor{rid, f.Id, name}, nil
+		r.Id = rid
+		r.IdFleet = f.Id
+		return r, nil
 	}
 }
 
-func (r Requestor) Update() (int64, error) {
-	if res, err := DBExec("UPDATE requestors SET id_fleet = ?, name = ? WHERE id_requestor = ?", r.IdFleet, r.Name, r.Id); err != nil {
-		return 0, err
-	} else if nb, err := res.RowsAffected(); err != nil {
-		return 0, err
-	} else {
-		return nb, err
-	}
+func (r Requestor) Update(ur Requestor) (Requestor, error) {
+	_, err := DBExec("UPDATE requestors SET id_fleet = ?, name = ? WHERE id_requestor = ?", ur.IdFleet, ur.Name, r.Id)
+	ur.Id = r.Id
+	return ur, err
 }
 
 func (r Requestor) Delete() (int64, error) {
diff --git a/server/models/vehicle.go b/server/models/vehicle.go
index 4590af8..6f28abb 100644
--- a/server/models/vehicle.go
+++ b/server/models/vehicle.go
@@ -1,6 +1,9 @@
 package filicop
 
-import ()
+import (
+	"errors"
+	"fmt"
+)
 
 type Vehicle struct {
 	Id      int64  `json:"id"`
@@ -29,29 +32,57 @@ func GetVehicles() (vehicles []Vehicle, err error) {
 	}
 }
 
+func (f Fleet) GetVehicles() (vehicles []Vehicle, err error) {
+	if rows, errr := DBQuery("SELECT id_vehicle, id_fleet, label FROM vehicles WHERE id_fleet = ?", f.Id); errr != nil {
+		return nil, errr
+	} else {
+		defer rows.Close()
+
+		for rows.Next() {
+			var v Vehicle
+			if err = rows.Scan(&v.Id, &v.IdFleet, &v.Label); err != nil {
+				return
+			}
+			vehicles = append(vehicles, v)
+		}
+		if err = rows.Err(); err != nil {
+			return
+		}
+
+		return
+	}
+}
+
 func GetVehicle(id int64) (v Vehicle, err error) {
 	err = DBQueryRow("SELECT id_vehicle, id_fleet, label FROM vehicles WHERE id_vehicle = ?", id).Scan(&v.Id, &v.IdFleet, &v.Label)
 	return
 }
 
-func (f Fleet) NewVehicle(label string) (Vehicle, error) {
-	if res, err := DBExec("INSERT INTO vehicles (id_fleet, label) VALUES (?, ?)", f.Id, label); err != nil {
-		return Vehicle{}, err
+func (f Fleet) GetVehicle(id int64) (v Vehicle, err error) {
+	err = DBQueryRow("SELECT id_vehicle, id_fleet, label FROM vehicles WHERE id_vehicle = ? AND id_fleet = ?", id, f.Id).Scan(&v.Id, &v.IdFleet, &v.Label)
+	return
+}
+
+func (f Fleet) NewVehicle(v Vehicle) (Vehicle, error) {
+	if v.IdFleet != 0 && v.IdFleet != f.Id {
+		return v, errors.New(fmt.Sprintf("Vehicle fleet ID is %d, but try to add it to fleet %d.", v.IdFleet, f.Id))
+	}
+
+	if res, err := DBExec("INSERT INTO vehicles (id_fleet, label) VALUES (?, ?)", f.Id, v.Label); err != nil {
+		return v, err
 	} else if vid, err := res.LastInsertId(); err != nil {
-		return Vehicle{}, err
+		return v, err
 	} else {
-		return Vehicle{vid, f.Id, label}, nil
+		v.Id = vid
+		v.IdFleet = f.Id
+		return v, nil
 	}
 }
 
-func (v Vehicle) Update() (int64, error) {
-	if res, err := DBExec("UPDATE vehicles SET id_fleet = ?, label = ? WHERE id_vehicle = ?", v.IdFleet, v.Label, v.Id); err != nil {
-		return 0, err
-	} else if nb, err := res.RowsAffected(); err != nil {
-		return 0, err
-	} else {
-		return nb, err
-	}
+func (v Vehicle) Update(uv Vehicle) (Vehicle, error) {
+	_, err := DBExec("UPDATE vehicles SET id_fleet = ?, label = ? WHERE id_vehicle = ?", uv.IdFleet, uv.Label, v.Id)
+	uv.Id = v.Id
+	return uv, err
 }
 
 func (v Vehicle) Delete() (int64, error) {