Issue #38 - Get Organization Endpoint

server/db/repo/category.go

@@ -0,0 +1,39 @@
+package repo
+
+import (
+	"github.com/golang/sync/syncmap"
+
+	"github.com/Coderockr/vitrine-social/server/model"
+	"github.com/jmoiron/sqlx"
+)
+
+// CategoryRepository to access database
+type CategoryRepository struct {
+	db *sqlx.DB
+}
+
+var categoryCache = syncmap.Map{}
+
+// NewCategoryRepository create a new repository
+func NewCategoryRepository(db *sqlx.DB) *CategoryRepository {
+
+	return &CategoryRepository{
+		db: db,
+	}
+}
+
+// Get a category from database using its id
+func (r *CategoryRepository) Get(id int64) (model.Category, error) {
+	if c, ok := categoryCache.Load(id); ok {
+		return c.(model.Category), nil
+	}
+
+	c := model.Category{}
+	err := r.db.Get(&c, "SELECT * FROM categories WHERE id = $1", id)
+	if err != nil {
+		return model.Category{}, err
+	}
+
+	categoryCache.Store(id, c)
+	return c, nil
+}

server/db/repo/need.go

@@ -0,0 +1,43 @@
+package repo
+
+import (
+	"github.com/Coderockr/vitrine-social/server/model"
+	"github.com/jmoiron/sqlx"
+)
+
+// NeedRepository is a implementation for Postgres
+type NeedRepository struct {
+	db      *sqlx.DB
+	catRepo *CategoryRepository
+}
+
+// NewNeedRepository creates a new repository
+func NewNeedRepository(db *sqlx.DB) *NeedRepository {
+	return &NeedRepository{
+		db:      db,
+		catRepo: NewCategoryRepository(db),
+	}
+}
+
+// Get one Need from database
+func (r *NeedRepository) Get(id int64) (*model.Need, error) {
+	var n *model.Need
+	err := r.db.Get(n, "SELECT * FROM needs WHERE id = $1", id)
+	if err != nil {
+		return nil, err
+	}
+
+	n.Category, err = r.catRepo.Get(n.CategoryID)
+	return n, nil
+}
+
+// GetNeedImages without the need data
+func (r *NeedRepository) getNeedImages(n *model.Need) ([]model.NeedImage, error) {
+	images := []model.NeedImage{}
+	err := r.db.Select(&images, "SELECT * FROM needs_images WHERE need_id = $1", n.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return images, nil
+}

server/db/repo/organization.go

@@ -0,0 +1,58 @@
+package repo
+
+import (
+	"fmt"
+
+	"github.com/Coderockr/vitrine-social/server/model"
+	"github.com/jmoiron/sqlx"
+)
+
+// OrganizationRepository is a implementation for Postgres
+type OrganizationRepository struct {
+	db       *sqlx.DB
+	catRepo  *CategoryRepository
+	needRepo *NeedRepository
+}
+
+// NewOrganizationRepository creates a new repository
+func NewOrganizationRepository(db *sqlx.DB) *OrganizationRepository {
+	return &OrganizationRepository{
+		db:       db,
+		catRepo:  NewCategoryRepository(db),
+		needRepo: NewNeedRepository(db),
+	}
+}
+
+// Get one Organization from database
+func (r *OrganizationRepository) Get(id int64) (*model.Organization, error) {
+	o := &model.Organization{}
+	err := r.db.Get(o, "SELECT * FROM organizations WHERE id = $1", id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r.db.Select(&o.Images, "SELECT * FROM organizations_images WHERE organization_id = $1", id)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r.db.Select(&o.Needs, "SELECT * FROM needs WHERE organization_id = $1", id)
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range o.Needs {
+		o.Needs[i].Category, err = r.catRepo.Get(o.Needs[i].CategoryID)
+		if err != nil {
+			fmt.Println("test?")
+			return nil, err
+		}
+
+		o.Needs[i].Images, err = r.needRepo.getNeedImages(&o.Needs[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return o, nil
+}

server/main.go

@@ -10,36 +10,39 @@ import (
 	"github.com/Coderockr/vitrine-social/server/auth"
 	"github.com/Coderockr/vitrine-social/server/db"
 	"github.com/Coderockr/vitrine-social/server/db/inmemory"
-	"github.com/gorilla/context"
+	"github.com/Coderockr/vitrine-social/server/db/repo"
+	"github.com/Coderockr/vitrine-social/server/routes"
 	"github.com/gorilla/mux"
 	"github.com/joho/godotenv"
 )
 
 func main() {
 
 	env := os.Getenv("VITRINESOCIAL_ENV")
-	err := godotenv.Load("config/" + env + ".env")
+	err := godotenv.Load("server/config/" + env + ".env")
 	if err != nil {
-		log.Fatal("Error loading .env file")
+		log.Fatal("Error loading file ", "server/onfig/"+env+".env")
 	}
 	StartServer()
 }
 
 //StartServer rotas e handlers
 func StartServer() {
 	dbConf := db.DBConfig{
-		os.Getenv("DATABASE_USER"),
-		os.Getenv("DATABASE_PASSWORD"),
-		os.Getenv("DATABASE_NAME"),
-		os.Getenv("DATABASE_HOST"),
-		os.Getenv("DATABASE_PORT"),
-		10,
+		User:     os.Getenv("DATABASE_USER"),
+		Passwd:   os.Getenv("DATABASE_PASSWORD"),
+		DBName:   os.Getenv("DATABASE_NAME"),
+		DBHost:   os.Getenv("DATABASE_HOST"),
+		DBPort:   os.Getenv("DATABASE_PORT"),
+		Attempts: 10,
 	}
-	_, err := db.InitDb(dbConf)
+	conn, err := db.InitDb(dbConf)
 	if err != nil {
 		log.Fatalf("Error initializing database: %v\n", err)
 	}
 
+	oR := repo.NewOrganizationRepository(conn)
+
 	mux := mux.NewRouter()
 	options := auth.Options{
 		SigningMethod: "RS256",
@@ -51,13 +54,15 @@ func StartServer() {
 	// creates the route with Bolt and JWT options
 	authRoute := auth.NewAuthRoute(inmemory.NewUserRepository(), options)
 	v1 := mux.PathPrefix("/v1").Subrouter()
-	authSub := v1.PathPrefix("/auth").Subrouter()
-	authSub.HandleFunc("/login", authRoute.Login)
-	v1.HandleFunc("/search", func(w http.ResponseWriter, req *http.Request) {
 
-	})
+	v1.HandleFunc("/auth/login", authRoute.Login)
+
+	v1.HandleFunc("/search", func(w http.ResponseWriter, req *http.Request) {})
+
+	organizationRoute := routes.NewOrganizationRoute(oR)
+	v1.HandleFunc("/organization/{id:[0-9]+}", organizationRoute.Get)
 
-	err = http.ListenAndServe(":"+os.Getenv("API_PORT"), context.ClearHandler(mux))
+	err = http.ListenAndServe(":"+os.Getenv("API_PORT"), mux)
 	if err != nil {
 		log.Fatal(err)
 	}

server/model/model.go

@@ -7,6 +7,13 @@ type User struct {
 	ID       int64  `valid:"-"`
 }
 
+// Image vinculada a uma necessidade
+type image struct {
+	ID   int64  `valid:"required" db:"id"`
+	Name string `db:"name"`
+	URL  string `valid:"required" db:"url"`
+}
+
 //Organization dados dos usuários que podem logar no sistema
 type Organization struct {
 	User
@@ -17,4 +24,41 @@ type Organization struct {
 	Resume  string `db:"resume"`
 	Video   string `valid:"required" db:"video"`
 	Slug    string `valid:"required" db:"slug"`
+	Needs   []Need
+	Images  []OrganizationImage
+}
+
+// OrganizationImage de uma organização
+type OrganizationImage struct {
+	image
+	OrganizationID int64 `valid:"required" db:"organization_id"`
+}
+
+// Need uma necessidade da organização
+type Need struct {
+	ID               int64   `valid:"required" db:"id"`
+	Title            string  `valid:"required" db:"title"`
+	Description      string  `valid:"required" db:"description"`
+	RequiredQuantity int     `db:"required_qtd"`
+	ReachedQuantity  int     `db:"reached_qtd"`
+	Unity            string  `valid:"required" db:"unity"`
+	DueDate          *string `db:"due_date"`
+	Status           string  `valid:"required" db:"status"`
+	CategoryID       int64   `valid:"required" db:"category_id"`
+	OrganizationID   int64   `valid:"required" db:"organization_id"`
+	Category         Category
+	Images           []NeedImage
+}
+
+// NeedImage de uma necessidade
+type NeedImage struct {
+	image
+	NeedID int64 `valid:"required" db:"need_id"`
+}
+
+// Category de uma necessidade
+type Category struct {
+	ID   int64  `valid:"required" db:"id"`
+	Name string `valid:"required" db:"name"`
+	Icon string `valid:"required" db:"icon"`
 }

server/routes/error.go

@@ -0,0 +1,21 @@
+package routes
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// ErrorMessage is a JSON formatter
+type ErrorMessage struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+// HandleHttpError formats and returns errors
+func HandleHttpError(w http.ResponseWriter, errno int, err error) {
+	w.WriteHeader(errno)
+	json.NewEncoder(w).Encode(&ErrorMessage{
+		Code:    errno,
+		Message: err.Error(),
+	})
+}