Co-authored-by: Octavio Carpes <octaviocarpes@users.noreply.github.com>

Co-authored-by: Bolivar Pereira <bolipereira@users.noreply.github.com>
Co-authored-by: Gustavo Jesinski <Jesinski@users.noreply.github.com>

.gitignore

@@ -14,4 +14,5 @@
 # Dependency directories (remove the comment below to include it)
 # vendor/
 
-/bin
\ No newline at end of file
+/bin
+.env
\ No newline at end of file

Dockerfile

@@ -18,7 +18,7 @@ RUN go mod download
 COPY . .
 
 # Build the application
-RUN go build -o ./bin/main ./cmd
+RUN go build -o ./bin/main ./cmd/server
 
 # Move to /build/bin and set permissions to the executable
 WORKDIR /build/bin

cmd/server/api.go

@@ -15,7 +15,15 @@ func registerAPI(handlers map[string]Router) http.Handler {
 	api := r.NewRoute().PathPrefix("/api").Subrouter()
 
 	handlers[UserRouter].RegisterRoutes(api.NewRoute().PathPrefix(UserPath).Subrouter())
+	handlers[SubjectRouter].RegisterRoutes(api.NewRoute().PathPrefix(SubjectPath).Subrouter())
+	handlers[WeeklyRoutineRouter].RegisterRoutes(api.NewRoute().PathPrefix(WeeklyRoutinePath).Subrouter())
 	handlers[RoutinePlanRouter].RegisterRoutes(api.NewRoute().PathPrefix(RoutinePlanPath).Subrouter())
 
+	r.NewRoute().HandlerFunc(HealthHandler)
+
 	return r
 }
+
+func HealthHandler(rw http.ResponseWriter, r *http.Request) {
+	rw.Write([]byte("{ \"health\": \"up\" }"))
+}

cmd/server/main.go

@@ -4,13 +4,17 @@ import (
 	"net/http"
 
 	"tools.ages.pucrs.br/notar-e-anotar/notar-e-anotar-back-end/pkg/routine_plans"
+	"tools.ages.pucrs.br/notar-e-anotar/notar-e-anotar-back-end/pkg/subjects"
 	"tools.ages.pucrs.br/notar-e-anotar/notar-e-anotar-back-end/pkg/user"
+	"tools.ages.pucrs.br/notar-e-anotar/notar-e-anotar-back-end/pkg/weekly_routines"
 )
 
 func main() {
 	handlers := map[string]Router{
-		UserRouter:        user.NewUserRouter(),
-		RoutinePlanRouter: routine_plans.NewRoutinePlanRouter(),
+		UserRouter:          user.NewUserRouter(),
+		SubjectRouter:       subjects.NewSubjectsRouter(),
+		WeeklyRoutineRouter: weekly_routines.NewWeeklyRoutinesRouter(),
+		RoutinePlanRouter:   routine_plans.NewRoutinePlanRouter(),
 	}
 
 	api := registerAPI(handlers)

docker-compose.yaml

+services:
+    backend:
+        # image: notareanotarbackend
+        ports:
+            - "80:8080"
+        networks:
+            - back-tier
+        build: .
+    database:
+        image: notareanotardatabase
+        volumes:
+            - db-data:/home/data
+        ports:
+            - "27017:27017"
+        networks: 
+            - back-tier
+        build: ../notar-e-anotar-database/Dockerfile
+
+volumes:
+    db-data:
+
+networks:
+    back-tier: {}
\ No newline at end of file

pkg/routine_days/router.go

+package routine_days
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+type RoutineDaysRouter struct{}
+
+func NewRoutineDaysRouter() *RoutineDaysRouter {
+	return &RoutineDaysRouter{}
+}
+
+func (u *RoutineDaysRouter) RegisterRoutes(r *mux.Router) {
+	r.Path("/").Methods(http.MethodGet).HandlerFunc(u.GetAll)
+	r.Path("/{id}").Methods(http.MethodGet).HandlerFunc(u.Get)
+	r.PathPrefix("/").Methods(http.MethodPut).HandlerFunc(u.Put)
+	r.PathPrefix("/").Methods(http.MethodPost).HandlerFunc(u.Post)
+}
+
+func (u *RoutineDaysRouter) Get(rw http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+
+	rw.Write([]byte(vars["id"]))
+}
+
+func (u *RoutineDaysRouter) GetAll(rw http.ResponseWriter, r *http.Request) {
+	rw.Write([]byte("list"))
+}
+
+func (u *RoutineDaysRouter) Put(rw http.ResponseWriter, r *http.Request) {
+	rw.Write([]byte("put"))
+}
+
+func (u *RoutineDaysRouter) Post(rw http.ResponseWriter, r *http.Request) {
+	// TODO: get routine days json from body
+	//       unmarshal json bytes to RoutineDays{}
+
+	// err := create(ctx)
+
+	rw.Write([]byte("post"))
+}

pkg/routine_days/routine_days.go

+package routine_days
+
+// type RoutineDays struct {
+// 	// DefaultModel adds _id, created_at and updated_at fields to the Model
+// 	mgm.DefaultModel `bson:",inline"`
+// 	Date             time.Date `json:"date", bson:"date"`
+// 	Chores           []string  `json:"chores", bson:"chores"`
+// 	routine_data     []string  `json:"routines_data", bson:"routines_data"`
+// }
+
+// func create(ctx context.Context, routineDays RoutineDays) error {
+// 	coll := mgm.Coll(&RoutineDays{})
+
+// 	return coll.CreateWithCtx(ctx, routineDays)
+// }

pkg/subjects/router.go

+package subjects
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+type SubjectsRouter struct{}
+
+func NewSubjectsRouter() *SubjectsRouter {
+	return &SubjectsRouter{}
+}
+
+func (u *SubjectsRouter) RegisterRoutes(r *mux.Router) {
+	r.Path("/").Methods(http.MethodGet).HandlerFunc(u.GetAll)
+	r.Path("/{name}").Methods(http.MethodGet).HandlerFunc(u.Get)
+}
+
+func (u *SubjectsRouter) Get(rw http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+
+	subject, err := findByName(r.Context(), vars["name"])
+	if err != nil {
+		log.Printf("error finding subject by name: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(subject)
+	if err != nil {
+		log.Printf("error marshaling subject: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Write(bytes)
+}
+
+func (u *SubjectsRouter) GetAll(rw http.ResponseWriter, r *http.Request) {
+	subjects, err := findAll(r.Context())
+	if err != nil {
+		log.Printf("error finding subjects: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(subjects)
+	if err != nil {
+		log.Printf("error marshaling subjects: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Write(bytes)
+}

pkg/subjects/subject.go

+package subjects
+
+import (
+	"context"
+
+	"github.com/kamva/mgm/v3"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+type Subject struct {
+	// DefaultModel adds _id, created_at and updated_at fields to the Model
+	mgm.DefaultModel `bson:",inline"`
+	Name             string `json:"name" bson:"name"`
+}
+
+func findByName(ctx context.Context, name string) (Subject, error) {
+	coll := mgm.Coll(&Subject{})
+
+	result, err := coll.Find(ctx, bson.M{"name": name})
+	if err != nil {
+		return Subject{}, err
+	}
+
+	subjects := make([]Subject, 0)
+	err = result.All(ctx, &subjects)
+	if err != nil {
+		return Subject{}, err
+	}
+
+	return subjects[0], nil
+}
+
+func findAll(ctx context.Context) ([]Subject, error) {
+	coll := mgm.Coll(&Subject{})
+
+	result, err := coll.Find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+
+	subjects := make([]Subject, 0)
+	err = result.All(ctx, &subjects)
+	if err != nil {
+		return nil, err
+	}
+
+	return subjects, nil
+}

pkg/tasks/router.go

+package tasks

pkg/tasks/tasks.go

+package tasks

pkg/user/server.go → pkg/user/router.go

@@ -26,7 +26,7 @@ func (u *UserRouter) Get(rw http.ResponseWriter, r *http.Request) {
 }
 
 func (u *UserRouter) GetAll(rw http.ResponseWriter, r *http.Request) {
-	rw.Write([]byte("getAll"))
+	rw.Write([]byte("list"))
 }
 
 func (u *UserRouter) Put(rw http.ResponseWriter, r *http.Request) {

pkg/user/user.go

+package user

pkg/weekly_routines/router.go

+package weekly_routines
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+type WeeklyRoutinesRouter struct{}
+
+func NewWeeklyRoutinesRouter() *WeeklyRoutinesRouter {
+	return &WeeklyRoutinesRouter{}
+}
+
+func (u *WeeklyRoutinesRouter) RegisterRoutes(r *mux.Router) {
+	r.Path("/").Methods(http.MethodGet).HandlerFunc(u.GetAll)
+}
+
+func (u *WeeklyRoutinesRouter) GetAll(rw http.ResponseWriter, r *http.Request) {
+	weeklyRoutines, err := findAll(r.Context())
+	if err != nil {
+		log.Printf("error finding weekly routines: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	bytes, err := json.Marshal(weeklyRoutines)
+	if err != nil {
+		log.Printf("error marshaling weekly routines: %s", err)
+		rw.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	rw.Write(bytes)
+}

pkg/weekly_routines/weekly_routines.go

+package weekly_routines
+
+import (
+	"context"
+
+	"github.com/kamva/mgm/v3"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+type routine_day_id struct {
+	Routine_day_id primitive.ObjectID `json:"routine_day_id" bson:"routine_day_id"`
+}
+type WeeklyRoutine struct {
+	mgm.DefaultModel `bson:",inline"`
+	Year             primitive.DateTime `json:"year" bson:"year"`
+	Routine_plan_id  primitive.ObjectID `json:"routine_plan_id" bson:"routine_plan_id"`
+	Week_number      int32              `json:"week_number" bson:"week_number"`
+	Wubject          primitive.ObjectID `json:"subject" bson:"subject"`
+	Routine_days     []routine_day_id   `json:"routine_days" bson:"routine_days"`
+}
+
+func findAll(ctx context.Context) ([]WeeklyRoutine, error) {
+	coll := mgm.Coll(&WeeklyRoutine{})
+
+	result, err := coll.Find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+
+	weekly_routines := make([]WeeklyRoutine, 0)
+	err = result.All(ctx, &weekly_routines)
+	if err != nil {
+		return nil, err
+	}
+
+	return weekly_routines, nil
+}