Feat/gh-111/badge_threshold

.gitignore

@@ -29,12 +29,14 @@ _ignored/
 .vscode/launch.json
 .vscode/extensions.json
 *.code-workspace
-
+*.gitconfig
 # VisualStudioCode Patch
 # Ignore all local history of files
 .history
 .ionide
 
 # MacOS
 .DS_Store
-.idea
+.idea
+
+samconfig.yaml

docs/api2.yaml

@@ -1143,6 +1143,9 @@ components:
         label:
           type: string
           example: Becoming vegetarian
+        points:
+          type: int
+          example: 30
         description:
           type: string
           example: I will not eat any meat from any animal (including fish).
@@ -1157,6 +1160,7 @@ components:
               id: no-beef
               label: Not eating beef
               description: I will avoid eating beef (Goodbye stake).
+              points: 30
     Date:
       type: string
       pattern: '\d{4}-\d{2}-\d{2}'

internal/crowdactions/crowdaction.go

@@ -0,0 +1,42 @@
+package crowdaction
+
+import (
+	"context"
+	"fmt"
+
+	m "github.com/CollActionteam/collaction_backend/internal/models"
+	"github.com/CollActionteam/collaction_backend/utils"
+)
+
+type Service interface {
+	GetCrowdactionById(ctx context.Context, crowdactionId string) (*m.CrowdactionData, error)
+	GetCrowdactionsByStatus(ctx context.Context, status string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error)
+}
+type CrowdactionManager interface {
+	GetById(pk string, crowdactionId string) (*m.CrowdactionData, error)
+	GetByStatus(filterCond string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error)
+}
+
+const (
+	KeyDateStart      = "date_start"
+	KeyDateEnd        = "date_end"
+	KeyDateJoinBefore = "date_limit_join"
+)
+
+type crowdactionService struct {
+	crowdactionRepository CrowdactionManager
+}
+
+func NewCrowdactionService(crowdactionRepository CrowdactionManager) Service {
+	return &crowdactionService{crowdactionRepository: crowdactionRepository}
+}
+
+func (e *crowdactionService) GetCrowdactionById(ctx context.Context, crowdactionID string) (*m.CrowdactionData, error) {
+	fmt.Println("GetCrowdactionById", crowdactionID)
+	return e.crowdactionRepository.GetById(utils.PKCrowdaction, crowdactionID)
+}
+
+func (e *crowdactionService) GetCrowdactionsByStatus(ctx context.Context, status string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error) {
+	fmt.Println("GetCrowdactionsByStatus", status, startFrom)
+	return e.crowdactionRepository.GetByStatus(status, startFrom)
+}

internal/crowdactions/crowdaction_test.go

@@ -0,0 +1,36 @@
+package crowdaction_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	cwd "github.com/CollActionteam/collaction_backend/internal/crowdactions"
+	m "github.com/CollActionteam/collaction_backend/internal/models"
+	"github.com/CollActionteam/collaction_backend/pkg/mocks/repository"
+
+	"github.com/CollActionteam/collaction_backend/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCrowdaction_GetCrowdactionById(t *testing.T) {
+	as := assert.New(t)
+	dynamoRepository := &repository.Dynamo{}
+	var ctx context.Context
+	var crowdactions *m.CrowdactionData
+	crowdactionID := "sustainability#food#185f66fd"
+
+	t.Run("dev stage", func(t *testing.T) {
+		dynamoRepository.On("GetById", utils.PKCrowdaction, crowdactionID).Return(crowdactions, nil).Once()
+
+		service := cwd.NewCrowdactionService(dynamoRepository)
+
+		crowdaction, err := service.GetCrowdactionById(ctx, crowdactionID)
+
+		fmt.Println("Hello world", crowdaction)
+
+		as.NoError(err)
+
+		dynamoRepository.AssertExpectations(t)
+	})
+}

internal/models/commitment.go

@@ -0,0 +1,9 @@
+package models
+
+type CommitmentOption struct {
+	Id          string             `json:"id"`
+	Label       string             `json:"label"`
+	Description string             `json:"description"`
+	Requires    []CommitmentOption `json:"requires,omitempty"`
+	Points      int                `json:"points"`
+}

internal/models/crowdaction.go

@@ -0,0 +1,32 @@
+package models
+
+type CrowdactionRequest struct {
+	Data CrowdactionData `json:"data" validate:"required"`
+}
+
+type CrowdactionParticipant struct {
+	Name   string `json:"name,omitempty"`
+	UserID string `json:"userID,omitempty"`
+}
+
+type CrowdactionImages struct {
+	Card   string `json:"card,omitempty"`
+	Banner string `json:"banner,omitempty"`
+}
+
+type CrowdactionData struct {
+	CrowdactionID      string                   `json:"crowdactionID"`
+	Title              string                   `json:"title"`
+	Description        string                   `json:"description"`
+	Category           string                   `json:"category"`
+	Subcategory        string                   `json:"subcategory"`
+	Location           string                   `json:"location"`
+	DateStart          string                   `json:"date_start"`
+	DateEnd            string                   `json:"date_end"`
+	DateLimitJoin      string                   `json:"date_limit_join"`
+	PasswordJoin       string                   `json:"password_join"`
+	ParticipationCount int                      `json:"participant_count"`
+	TopParticipants    []CrowdactionParticipant `json:"top_participants"`
+	Images             CrowdactionImages        `json:"images"`
+	CommitmentOptions  []CommitmentOption       `json:"commitment_options"`
+}

pkg/handler/aws/crowdaction/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	cwd "github.com/CollActionteam/collaction_backend/internal/crowdactions"
+	"github.com/CollActionteam/collaction_backend/internal/models"
+	hnd "github.com/CollActionteam/collaction_backend/pkg/handler"
+	awsRepository "github.com/CollActionteam/collaction_backend/pkg/repository/aws"
+	"github.com/CollActionteam/collaction_backend/utils"
+	"github.com/aws/aws-lambda-go/events"
+	"github.com/aws/aws-lambda-go/lambda"
+	"github.com/go-playground/validator/v10"
+)
+
+func getCrowdactionByID(ctx context.Context, crowdactionID string) (events.APIGatewayV2HTTPResponse, error) {
+	dynamoRepository := awsRepository.NewCrowdaction(awsRepository.NewDynamo())
+	getCrowdaction, err := cwd.NewCrowdactionService(dynamoRepository).GetCrowdactionById(ctx, crowdactionID)
+
+	if err != nil {
+		return utils.CreateMessageHttpResponse(http.StatusInternalServerError, err.Error()), nil
+	}
+	if getCrowdaction == nil {
+		return utils.CreateMessageHttpResponse(http.StatusNotFound, "not participating"), nil
+	}
+
+	jsonPayload, _ := json.Marshal(getCrowdaction)
+	return events.APIGatewayV2HTTPResponse{
+		Body:       string(jsonPayload),
+		StatusCode: http.StatusOK,
+	}, nil
+}
+
+func getCrowdactionsByStatus(ctx context.Context, status string) (events.APIGatewayV2HTTPResponse, error) {
+	dynamoRepository := awsRepository.NewCrowdaction(awsRepository.NewDynamo())
+	getCrowdactions, err := cwd.NewCrowdactionService(dynamoRepository).GetCrowdactionsByStatus(ctx, status, nil)
+
+	if err != nil {
+		return utils.CreateMessageHttpResponse(http.StatusInternalServerError, err.Error()), nil
+	}
+	jsonPayload, _ := json.Marshal(getCrowdactions)
+
+	return events.APIGatewayV2HTTPResponse{
+		Body:       string(jsonPayload),
+		StatusCode: http.StatusOK,
+	}, nil
+}
+
+func handler(ctx context.Context, req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {
+	crowdactionID := req.PathParameters["crowdactionID"]
+	var request models.CrowdactionRequest
+
+	validate := validator.New()
+	if err := validate.StructCtx(ctx, request); err != nil {
+		body, _ := json.Marshal(hnd.Response{Status: hnd.StatusFail, Data: map[string]interface{}{"error": utils.ValidationResponse(err, validate)}})
+		return events.APIGatewayV2HTTPResponse{Body: string(body), StatusCode: http.StatusBadRequest}, nil
+	}
+
+	if crowdactionID == "" {
+		status := req.QueryStringParameters["status"]
+		return getCrowdactionsByStatus(ctx, status)
+	}
+
+	return getCrowdactionByID(ctx, crowdactionID)
+}
+
+func main() {
+	lambda.Start(handler)
+}
+
+func errToResponse(err error, code int) events.APIGatewayV2HTTPResponse {
+	msg, _ := json.Marshal(map[string]string{"message": err.Error()})
+	return events.APIGatewayV2HTTPResponse{Body: string(msg), StatusCode: code}
+}

pkg/handler/aws/emailContact/main.go

@@ -3,6 +3,8 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"net/http"
+
 	"github.com/CollActionteam/collaction_backend/internal/contact"
 	"github.com/CollActionteam/collaction_backend/internal/models"
 	hnd "github.com/CollActionteam/collaction_backend/pkg/handler"
@@ -12,7 +14,6 @@ import (
 	"github.com/aws/aws-lambda-go/lambda"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/go-playground/validator/v10"
-	"net/http"
 )
 
 func handler(ctx context.Context, req events.APIGatewayV2HTTPRequest) (events.APIGatewayV2HTTPResponse, error) {

pkg/mocks/repository/dynamoManager.go

@@ -0,0 +1,21 @@
+package repository
+
+import (
+	m "github.com/CollActionteam/collaction_backend/internal/models"
+	"github.com/CollActionteam/collaction_backend/utils"
+	"github.com/stretchr/testify/mock"
+)
+
+type Dynamo struct {
+	mock.Mock
+}
+
+func (d *Dynamo) GetById(pk string, sk string) (*m.CrowdactionData, error) {
+	args := d.Mock.Called(pk, sk)
+	return args.Get(0).(*m.CrowdactionData), args.Error(1)
+}
+
+func (d *Dynamo) GetByStatus(filterCond string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error) {
+	args := d.Mock.Called(filterCond, startFrom)
+	return args.Get(0).([]m.CrowdactionData), args.Error(1)
+}

pkg/repository/aws/crowdactionManager.go

@@ -0,0 +1,89 @@
+package aws
+
+import (
+	"fmt"
+
+	"github.com/CollActionteam/collaction_backend/internal/constants"
+	m "github.com/CollActionteam/collaction_backend/internal/models"
+	"github.com/CollActionteam/collaction_backend/utils"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
+	"github.com/aws/aws-sdk-go/service/dynamodb/expression"
+)
+
+type Crowdaction interface {
+	GetById(pk string, sk string) (*m.CrowdactionData, error)
+	GetByStatus(status string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error)
+}
+
+const (
+	KeyDateStart      = "date_start"
+	KeyDateEnd        = "date_end"
+	KeyDateJoinBefore = "date_limit_join"
+)
+
+type crowdaction struct {
+	dbClient *Dynamo
+}
+
+func NewCrowdaction(dynamo *Dynamo) Crowdaction {
+	return &crowdaction{dbClient: dynamo}
+}
+
+/**
+	GET Crowdaction by Id
+**/
+func (s *crowdaction) GetById(pk string, sk string) (*m.CrowdactionData, error) {
+	item, err := s.dbClient.GetDBItem(constants.TableName, pk, sk)
+
+	if item == nil || err != nil {
+		return nil, err
+	}
+
+	var c m.CrowdactionData
+	err = dynamodbattribute.UnmarshalMap(item, &c)
+
+	return &c, err
+}
+
+/**
+	GET Crowdaction by Status
+**/
+func (s *crowdaction) GetByStatus(status string, startFrom *utils.PrimaryKey) ([]m.CrowdactionData, error) {
+	crowdactions := []m.CrowdactionData{}
+	var filterCond expression.ConditionBuilder
+
+	switch status {
+	case "joinable":
+		filterCond = expression.Name(KeyDateJoinBefore).GreaterThan(expression.Value(utils.GetDateStringNow()))
+		fmt.Println("GetByStatus: joinable", filterCond)
+	case "active":
+		filterCond = expression.Name(KeyDateStart).LessThanEqual(expression.Value(utils.GetDateStringNow()))
+		fmt.Println("GetByStatus: active", filterCond)
+	case "ended":
+		filterCond = expression.Name(KeyDateEnd).LessThanEqual(expression.Value(utils.GetDateStringNow()))
+		fmt.Println("GetByStatus: ended", filterCond)
+	default:
+		fmt.Println("None of the edge cases matched")
+	}
+
+	items, err := s.dbClient.Query(constants.TableName, filterCond, startFrom)
+
+	if items == nil || err != nil {
+		return nil, err
+	}
+
+	for _, foo := range items {
+		var crowdaction m.CrowdactionData
+		err := dynamodbattribute.UnmarshalMap(foo, &crowdaction)
+
+		if err == nil {
+			crowdactions = append(crowdactions, crowdaction)
+		}
+	}
+
+	if len(items) != len(crowdactions) {
+		err = fmt.Errorf("error unmarshelling %d items", len(items)-len(crowdactions))
+	}
+
+	return crowdactions, err
+}