Skip to content

GitLab

Commit fa02e692 authored by Enrico Bollen's avatar Enrico Bollen 💬
Browse files

Merge branch 'dev' into feat/check-building-opening-times 

# Conflicts:
#	api/rest/controllers/room_controller_test.go
#	internal/model/building.go
#	internal/services/appointment_service_test.go
parents fffc18e6 5e61539f
Pipeline #1817 failed with stages
in 54 seconds
Hide whitespace changes
Inline Side-by-side
api/rest/controllers/appointment_controller.go deleted 100644 → 0
View file @ fffc18e6
package controllers
/*
// CreateAppointment creates an appointment.
func CreateAppointment() {
}
// GetAppointment finds a single appointment by startTime
func GetAppointment(startTime time.Time) {
}
// GetAllAppointments returns all the appointments
func GetAllAppointments() {
}
// UpdateAppointment updates a single appointment
func UpdateAppointment() {
}
// DeleteAppointment deletes a single appointment
func DeleteAppointment() {
}
*/
api/rest/controllers/building_controller.go deleted 100644 → 0
View file @ fffc18e6
package controllers
/*
// CreateBuilding Creates a single new building
func CreateBuilding() {
// Reserved for future use
}
// GetBuilding gets a single building
func GetBuilding() {
// Reserved for future use
}
// GetAllBuildings Returns all the buildings
func GetAllBuildings() {
// Reserved for future use
}
// UpdateBuilding Updates a single building
func UpdateBuilding() {
// Reserved for future use
}
// DeleteBuilding Deletes a single building
func DeleteBuilding(id int) {
// Reserved for future use
}
*/
api/rest/controllers/room_controller.go deleted 100644 → 0
View file @ fffc18e6
package controllers
import (
m "git.coco.study/fvitt/good2go/internal/model"
s "git.coco.study/fvitt/good2go/internal/services"
"log"
)
// RoomController Controller to handle all types of controller stuff
type RoomController struct{}
// CreateRoom *drumroll* creates a room
func CreateRoom(buildingId int, roomNo int, capacity int) *m.Room {
room, err := s.BuildingService.AddRoom(buildingId, roomNo, capacity)
if err != nil {
log.Fatal(err)
}
return room
}
// GetRoom gets a single room by id
func GetRoom(roomId int) (room *m.Room, err error) {
room, err = s.BuildingService.GetRoom(roomId)
return room, err
}
// GetAllRooms returns all the rooms
func GetAllRooms() map[int][]*m.Room {
return s.BuildingService.GetRooms()
}
// UpdateRoom updates a single room
func UpdateRoom(buildingId int, roomNo int, capacity int) (room *m.Room, err error) {
room, err = s.BuildingService.UpdateRoomCapacity(buildingId, roomNo, capacity)
return room, err
}
// DeleteRoom deletes a room by id
func DeleteRoom(buildingId, roomNo int) (err error) {
err = s.BuildingService.DeleteRoom(buildingId, roomNo)
if err != nil {
log.Fatal(err)
}
return err
}
api/rest/controllers/room_controller_test.go deleted 100644 → 0
View file @ fffc18e6
package controllers
import (
"reflect"
"testing"
"git.coco.study/fvitt/good2go/internal/model"
"git.coco.study/fvitt/good2go/internal/services"
)
var initialRoomAmount = 0
func isRoom(r *model.Room) bool {
if reflect.TypeOf(r.Capacity).Name() != "int" {
return false
}
if reflect.TypeOf(r.Number).Name() != "int" {
return false
}
return true
}
func TestCreateRooms(t *testing.T) {
services.BuildingService.AddBuilding("10:00", "10h", []string{"mon"})
room := CreateRoom(0, 420, 69)
if room.Number != 420 {
t.Errorf("Returned room didnt have the correct room number.")
}
if room.Capacity != 69 {
t.Errorf("Returned room didnt have the correct capacity.")
}
}
func TestGetRoom(t *testing.T) {
CreateRoom(0, 666, 66)
room, err := GetRoom(0, 666)
if err != nil {
t.Error(err)
}
if room.Capacity != 66 {
t.Errorf("first element in getAllRooms[] doesnt seem to be a room")
}
if room.Number != 666 {
t.Errorf("Created room didnt have the correct room number")
}
}
func TestGetAllRooms(t *testing.T) {
rooms := GetAllRooms()[0]
initialRoomAmount = len(rooms)
if initialRoomAmount > 0 && !isRoom(rooms[0]) {
t.Errorf("first element in getAllRooms[] doesnt seem to be a room")
}
}
func TestUpdateSingleRoom(t *testing.T) {
// GIVEN
CreateRoom(0, 34, 34)
// WHEN
_, updateErr := UpdateRoom(0, 34, 90)
if updateErr != nil {
t.Error(updateErr)
}
// THEN
room, err := GetRoom(0)
if err != nil {
t.Errorf("Could not find created room")
}
if room != nil {
if room.Capacity != 90 {
t.Error("Updated room didnt have the correct capacity")
}
}
}
func TestDeleteRoom(t *testing.T) {
// GIVEN
CreateRoom(0, 100, 100)
_, err := GetRoom(0, 100)
if err != nil {
t.Error(err.Error())
}
// WHEN
err = DeleteRoom(0, 100)
// THEN
_, err = GetRoom(0, 100)
if err == nil {
t.Error("Deleted room was not deleted")
}
}
api/rest/router.go
View file @ fa02e692
......@@ -31,7 +31,7 @@ func Init() {
r.Use(m.SentryHandler)
// Register all the Routers
h.RoomRouter.AttachRouter(r)
h.BuildingRouter.AttachRouter(r)
h.AppointmentRouter.AttachRouter(r)
h.HomeRouter.AttachRouter(r)
......
api/rest/subrouters/building_router.go 0 → 100644
View file @ fa02e692
package restapi
import (
"encoding/json"
"fmt"
"log"
"net/http"
u "git.coco.study/fvitt/good2go/api/rest/utils"
"git.coco.study/fvitt/good2go/internal/model"
s "git.coco.study/fvitt/good2go/internal/services"
"github.com/gorilla/mux"
)
type buildingRouter struct{}
var (
// BuildingRouter Handles requests to /building
BuildingRouter = &buildingRouter{}
)
func createBuilding(res http.ResponseWriter, req *http.Request) {
var buildingDTO model.Building
err := json.NewDecoder(req.Body).Decode(&model.Building{})
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
return
}
building, err := s.BuildingService.CreateBuilding(&buildingDTO)
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
return
}
err = u.SendJSON(res).Encode(building)
if err != nil {
fmt.Println(err)
}
}
func getBuilding(res http.ResponseWriter, req *http.Request) {
buildingID := mux.Vars(req)["buildingID"]
building, buildingErr := s.BuildingService.GetBuilding(buildingID)
if buildingErr == nil {
u.SendJSON(res).Encode(building)
} else {
http.Error(res, buildingErr.Error(), http.StatusNotFound)
}
}
func getAllBuildings(res http.ResponseWriter, req *http.Request) {
buildings, err := s.BuildingService.GetAllBuildings()
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
return
}
err = u.SendJSON(res).Encode(buildings)
if err != nil {
fmt.Println(err)
}
}
func deleteBuilding(res http.ResponseWriter, req *http.Request) {
buildingID := mux.Vars(req)["buildingID"]
err := s.BuildingService.DeleteBuilding(buildingID)
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
log.Fatal(err)
}
res.WriteHeader(http.StatusOK)
}
// AttachRouter initialize Router
func (a buildingRouter) AttachRouter(router *mux.Router) {
r := router.PathPrefix("/buildings/").Subrouter()
// CREATE
r.HandleFunc("/", createBuilding).Methods("POST")
// // READ
r.HandleFunc("/{buildingID}", getBuilding).Methods("GET")
r.HandleFunc("/", getAllBuildings).Methods("GET")
// // DELETE
r.HandleFunc("/{buildingID}", deleteBuilding).Methods("DELETE")
}
api/rest/subrouters/room_router.go
View file @ fa02e692
......@@ -3,37 +3,36 @@ package restapi
import (
"encoding/json"
"fmt"
c "git.coco.study/fvitt/good2go/api/rest/controllers"
"log"
"net/http"
u "git.coco.study/fvitt/good2go/api/rest/utils"
"git.coco.study/fvitt/good2go/internal/model"
s "git.coco.study/fvitt/good2go/internal/services"
"github.com/gorilla/mux"
"log"
"net/http"
"strconv"
)
type roomRouter struct{}
var (
// RoomRouter Handles requests to /room
RoomRouter = &roomRouter{}
RoomRouter = &buildingRouter{}
)
func createRoom(res http.ResponseWriter, req *http.Request) {
// Decode the body
type incoming struct {
Building int `json:"building"`
Number int `json:"number"`
Capacity int `json:"capacity"`
type roomDTO struct {
buildingID string
room model.Room
}
var r incoming
err := json.NewDecoder(req.Body).Decode(&incoming{})
var r roomDTO
err := json.NewDecoder(req.Body).Decode(&roomDTO{})
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
return
}
room := c.CreateRoom(r.Building, r.Number, r.Capacity)
room, err := s.BuildingService.CreateRoom(r.buildingID, &r.room)
err = u.SendJSON(res).Encode(room)
if err != nil {
......@@ -42,27 +41,21 @@ func createRoom(res http.ResponseWriter, req *http.Request) {
}
func getRoom(res http.ResponseWriter, req *http.Request) {
var roomId int
roomId, parseErr := strconv.Atoi(mux.Vars(req)["roomId"])
if parseErr == nil {
roomID := mux.Vars(req)["roomID"]
room, roomErr := c.GetRoom(roomId)
room, roomErr := s.BuildingService.GetRoom(roomID)
if roomErr == nil {
u.SendJSON(res).Encode(room)
} else {
http.Error(res, roomErr.Error(), http.StatusNotFound)
}
if roomErr == nil {
u.SendJSON(res).Encode(room)
} else {
http.Error(res, parseErr.Error(), http.StatusBadRequest)
http.Error(res, roomErr.Error(), http.StatusNotFound)
}
}
func getAllRooms(res http.ResponseWriter, req *http.Request) {
rooms := s.BuildingService.GetRooms()
rooms := s.BuildingService.GetAllRooms()
err := u.SendJSON(res).Encode(rooms)
if err != nil {
......@@ -71,20 +64,18 @@ func getAllRooms(res http.ResponseWriter, req *http.Request) {
}
func updateRoom(res http.ResponseWriter, req *http.Request) {
// Decode the body
type incoming struct {
Building int
Number int
Capacity int
}
var r incoming
roomID := mux.Vars(req)["roomID"]
var r model.Room
parseBodyErr := json.NewDecoder(req.Body).Decode(&r)
if parseBodyErr != nil {
http.Error(res, parseBodyErr.Error(), http.StatusBadRequest)
return
}
room, err := s.BuildingService.UpdateRoomCapacity(r.Building, r.Number, r.Capacity)
room, err := s.BuildingService.UpdateRoomCapacity(roomID, r.Capacity)
if err == nil {
err := u.SendJSON(res).Encode(room)
if err != nil {
......@@ -96,19 +87,10 @@ func updateRoom(res http.ResponseWriter, req *http.Request) {
}
func deleteRoom(res http.ResponseWriter, req *http.Request) {
type incoming struct {
Building int
Number int
Capacity int
}
var r incoming
parseBodyErr := json.NewDecoder(req.Body).Decode(&r)
if parseBodyErr != nil {
http.Error(res, parseBodyErr.Error(), http.StatusBadRequest)
return
}
err := s.BuildingService.DeleteRoom(r.Building, r.Number)
roomID := mux.Vars(req)["roomID"]
err := s.BuildingService.DeleteRoom(roomID)
if err != nil {
http.Error(res, err.Error(), http.StatusBadRequest)
log.Fatal(err)
......@@ -125,13 +107,13 @@ func (a roomRouter) AttachRouter(router *mux.Router) {
r.HandleFunc("/", createRoom).Methods("POST")
// READ
r.HandleFunc("/{roomNo}", getRoom).Methods("GET")
r.HandleFunc("/{roomID}", getRoom).Methods("GET")
r.HandleFunc("/", getAllRooms).Methods("GET")
// UPDATE
r.HandleFunc("/{roomNo}", updateRoom).Methods("PUT")
r.HandleFunc("/{roomID}", updateRoom).Methods("PUT")
// DELETE
r.HandleFunc("/{roomNo}", deleteRoom).Methods("DELETE")
r.HandleFunc("/{roomID}", deleteRoom).Methods("DELETE")
}
cmd/__debug_bin 0 → 100755
View file @ fa02e692
File added
cmd/main.go
View file @ fa02e692
......@@ -29,14 +29,22 @@ func main() {
// Create sample objects in memory for playing around
func initSampleData() {
//"08:00", "10h", []string{"mon", "tue", "wed", "thu", "fri", "sat"}
// Add Building
services.BuildingService.AddBuilding("08:00", "10h", []string{"mon", "tue", "wed", "thu", "fri", "sat"})
// Add Rooms
_, err := services.BuildingService.AddRoom(0, 310, 20)
building1 := &model.Building{}
building1.New("08:00", "10h", []string{"mon", "tue", "wed", "thu", "fri", "sat"})
building, _ := services.BuildingService.CreateBuilding(building1)
_, err := services.BuildingService.CreateRoom(building.ID.String(), &model.Room{
Number: 320,
Capacity: 10,
})
if err != nil {
log.Fatal(err)
}
//model.Building.AddRoom(520, 50)
//model.Building.CreateRoom(520, 50)
// Add sample Appointments
a1, _ := model.Appointment{}.New("27-11-2016 10:00", "2h")
......
database/mongo/main.go
View file @ fa02e692
......@@ -9,9 +9,9 @@ import (
)
var (
// RoomRepository does crud stuff
RoomRepo *repositories.Repository
BuildingRepo *repositories.Repository
RoomRepo *repositories.Repository
BuildingRepo *repositories.Repository
AppointmentRepo *repositories.Repository
)
// Init initializes connection to a database
......@@ -39,4 +39,8 @@ func Init() {
Col: db.Collection("buildings"),
}
AppointmentRepo = &repositories.Repository{
Col: db.Collection("appointments"),
}
}
database/mongo/repositories/appointments_repository.go
View file @ fa02e692
package repositories
import (
"git.coco.study/fvitt/good2go/internal/model"
"go.mongodb.org/mongo-driver/mongo"
)
type AppointmentRepository interface {
CreateRoom(r *model.Appointment) (*model.Appointment, error)
UpdateRoom(r *model.Appointment)
GetRoom(document interface{}) (room *model.Appointment, err error)
GetAllRooms() []model.Room
ConnectTo(c *mongo.Collection) *Repository
}
// func (repo *Repository) findAppointmentByID(roomID string) (*model.Appointment, error) {
// }
database/mongo/repositories/building_repository.go
View file @ fa02e692
package repositories
import (
"log"
"time"
"git.coco.study/fvitt/good2go/database/mongo/utils"
"git.coco.study/fvitt/good2go/internal/model"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
)
......@@ -16,14 +18,55 @@ type BuildingRepository interface {
UpdateBuilding(id interface{}, building *model.Building) (*mongo.UpdateResult, error)
}
func (repo *Repository) CreateBuilding(building *model.Building) (*mongo.InsertOneResult, error) {
func (repo *Repository) findBuildingByID(buildingID string) (*model.Building, error) {
ctx, cancel := utils.CreateTimeoutCTX(5 * time.Second)
defer cancel()
id, err := primitive.ObjectIDFromHex(buildingID)
if err != nil {
return nil, err
}
res, err := repo.Col.Find(ctx, bson.M{"_id": id})
if err != nil {
return nil, err
}
building := model.Building{}
err = res.Decode(&building)
if err != nil {
return nil, err
}
return &building, err
}
func (repo *Repository) CreateBuilding(building *model.Building) (*model.Building, error) {
ctx, cancel := utils.CreateTimeoutCTX(time.Second * 10)
defer cancel()
res, err := repo.Col.InsertOne(ctx, &building)
// Create
insertedRes, err := repo.Col.InsertOne(ctx, &building)
if err != nil {
return nil, err
}
return res, nil
// Get
res, err := repo.Col.Find(ctx, bson.M{"_id": insertedRes.InsertedID})
if err != nil {
return nil, err
}