Add docker

services/entry/pkg/application/projects/model.go

@@ -0,0 +1,31 @@
+package projects
+
+type Project struct {
+	Id        int
+	Name      string
+	MemberIds []int
+	AdminIds  []int
+}
+
+func NewProject(id int, name string, memberIds []int, adminIds []int) *Project {
+	return &Project{
+		Id:        id,
+		Name:      name,
+		MemberIds: memberIds,
+		AdminIds:  adminIds,
+	}
+}
+
+type CreateProject struct {
+	Name      string
+	MemberIds []int
+	AdminIds  []int
+}
+
+func NewCreateProject(name string, userId int) *CreateProject {
+	return &CreateProject{
+		Name:      name,
+		MemberIds: []int{userId},
+		AdminIds:  []int{userId},
+	}
+}

services/entry/pkg/application/projects/repository.go

@@ -0,0 +1,8 @@
+package projects
+
+import "context"
+
+type Repository interface {
+	Create(ctx context.Context, project *CreateProject) (int, error)
+	GetForMemberId(ctx context.Context, memberId int) ([]*Project, error)
+}

services/entry/pkg/application/projects/service.go

@@ -0,0 +1,59 @@
+package projects
+
+import (
+	"context"
+	"fmt"
+	"github.com/eko/gocache/cache"
+	"go.uber.org/zap"
+)
+
+type Service struct {
+	projectsRepository Repository
+	logger             *zap.Logger
+	cache              *cache.MetricCache
+}
+
+func NewService(logger *zap.Logger, projectsRepository Repository, cache *cache.MetricCache) *Service {
+	return &Service{
+		logger:             logger,
+		projectsRepository: projectsRepository,
+		cache:              cache}
+}
+
+func (s *Service) CreateProject(ctx context.Context, userId int, name string) (int, error) {
+	s.logger.Debug("creating project",
+		zap.String("name", name),
+		zap.Int("creatorId", userId))
+
+	projectId, err := s.projectsRepository.Create(ctx, NewCreateProject(name, userId))
+	if err != nil {
+		s.logger.Warn(err.Error())
+		return -1, err
+	}
+
+	_ = s.cache.Delete(fmt.Sprintf("projects_userId_%d", userId))
+
+	return projectId, nil
+}
+
+func (s *Service) Get(ctx context.Context, userId int) ([]*Project, error) {
+	s.logger.Debug("getting projects",
+		zap.Int("userId", userId))
+
+	loadFunc := func(key interface{}) (interface{}, error) {
+		s.logger.Debug("getting projects from repository",
+			zap.Int("userId", userId))
+		return s.projectsRepository.GetForMemberId(ctx, userId)
+	}
+
+	cacheEntry := cache.NewLoadable(
+		loadFunc,
+		s.cache)
+
+	entry, err := cacheEntry.Get(fmt.Sprintf("projects_userId_%d", userId))
+	if err != nil {
+		return nil, err
+	}
+
+	return entry.([]*Project), nil
+}

services/entry/pkg/application/users/model.go

@@ -0,0 +1,10 @@
+package users
+
+type User struct {
+	Id    int
+	Email string
+}
+
+func NewUser(id int, email string) *User {
+	return &User{id, email}
+}

services/entry/pkg/application/users/repository.go

@@ -0,0 +1,8 @@
+package users
+
+import "context"
+
+type Repository interface {
+	Create(ctx context.Context, user *CreateUser) (int, error)
+	GetByEmail(ctx context.Context, email string, passwordHash string) (*User, error)
+}

services/entry/pkg/application/users/service.go

@@ -0,0 +1,54 @@
+package users
+
+import (
+	"context"
+	"fmt"
+	"github.com/eko/gocache/cache"
+	"go.uber.org/zap"
+)
+
+type Service struct {
+	logger         *zap.Logger
+	cache          *cache.MetricCache
+	repository     Repository
+	passwordHasher PasswordHasher
+}
+
+func NewService(l *zap.Logger, ur Repository, c *cache.MetricCache) *Service {
+	return &Service{
+		logger:         l,
+		repository:     ur,
+		cache:          c,
+		passwordHasher: NewPlainTextPasswordHasher(),
+	}
+}
+
+func (s *Service) Create(email string, password string) (int, error) {
+	createUser, err := NewCreateUser(email, password, s.passwordHasher)
+	if err != nil {
+		return -1, err
+	}
+
+	var userId int
+	userId, err = s.repository.Create(context.Background(), createUser)
+	if err != nil {
+		s.logger.Warn("Could not create user in service")
+		return 0, err
+	}
+
+	return userId, nil
+}
+
+func (s *Service) Authenticate(ctx context.Context, email string, password string) (*User, error) {
+	loadFunc := func(key interface{}) (interface{}, error) {
+		s.logger.Debug("getting user from cache", zap.String("email", email))
+		return s.repository.GetByEmail(ctx, email, s.passwordHasher.HashPassword(password))
+	}
+
+	get, err := cache.NewLoadable(loadFunc, s.cache).Get(fmt.Sprintf("user_email_%s", email))
+	if err != nil {
+		return nil, err
+	}
+
+	return get.(*User), nil
+}

services/entry/pkg/application/users/user.go

@@ -0,0 +1,49 @@
+package users
+
+import "errors"
+
+type PasswordHasher interface {
+	HashPassword(password string) string
+}
+
+type CreateUser struct {
+	Email        string
+	PasswordHash string
+}
+
+func NewCreateUser(email string, password string, hasher PasswordHasher) (*CreateUser, error) {
+	if email == "" {
+		return nil, errors.New("Email cannot be empty for user")
+	}
+	if password == "" || len(password) < 8 {
+		return nil, errors.New("password is doesn't fit requirements")
+	}
+
+	return &CreateUser{
+		Email:        email,
+		PasswordHash: hasher.HashPassword(password),
+	}, nil
+}
+
+type bCryptPasswordHasher struct {
+}
+
+func NewBCryptPasswordHasher() PasswordHasher {
+	return &bCryptPasswordHasher{}
+}
+
+func (b bCryptPasswordHasher) HashPassword(password string) string {
+	//TODO implement me
+	panic("implement me")
+}
+
+type plainTextPasswordHasher struct {
+}
+
+func NewPlainTextPasswordHasher() PasswordHasher {
+	return &plainTextPasswordHasher{}
+}
+
+func (p plainTextPasswordHasher) HashPassword(password string) string {
+	return password
+}

services/entry/pkg/db/db.go

@@ -0,0 +1,50 @@
+package db
+
+import (
+	"context"
+	"errors"
+	"github.com/jackc/pgx/v4/pgxpool"
+	"go.uber.org/zap"
+	"os"
+)
+
+type Client struct {
+	pool *pgxpool.Pool
+}
+
+func NewClient(l *zap.Logger) *Client {
+	l.Info("Setting up database connection")
+
+	dbPool := setupPool()
+	testConnection(dbPool)
+
+	l.Info("Database successfully connected")
+
+	return &Client{pool: dbPool}
+}
+
+func setupPool() *pgxpool.Pool {
+	dbUrl := os.Getenv("DATABASE_URL")
+	if dbUrl == "" {
+		panic(errors.New("DATABASE_URL is not set"))
+	}
+	dbPool, err := pgxpool.Connect(context.Background(), dbUrl)
+	if err != nil {
+		panic(err)
+	}
+
+	return dbPool
+}
+
+func testConnection(dbPool *pgxpool.Pool) {
+	var greeting string
+	err := dbPool.QueryRow(context.Background(), "select 'Hello, world!'").Scan(&greeting)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (c *Client) GetConn(ctx context.Context) *pgxpool.Conn {
+	conn, _ := c.pool.Acquire(ctx)
+	return conn
+}

services/entry/pkg/db/postgres/projectsRepository.go

@@ -0,0 +1,66 @@
+package postgres
+
+import (
+	"context"
+	"serverctl/pkg/application/projects"
+	"serverctl/pkg/db"
+)
+
+var _ projects.Repository = &ProjectsRepository{}
+
+type ProjectsRepository struct {
+	db *db.Client
+}
+
+func NewProjectsRepository(db *db.Client) projects.Repository {
+	return &ProjectsRepository{db: db}
+}
+
+type projectData struct {
+	Name      string `json:"name"`
+	MemberIds []int  `json:"memberIds"`
+	AdminIds  []int  `json:"adminIds"`
+}
+
+func NewProjectData(project *projects.CreateProject) projectData {
+	return projectData{
+		Name:      project.Name,
+		AdminIds:  project.AdminIds,
+		MemberIds: project.MemberIds,
+	}
+}
+
+func (p ProjectsRepository) Create(ctx context.Context, project *projects.CreateProject) (int, error) {
+	conn := p.db.GetConn(ctx)
+	defer conn.Release()
+
+	var projectId int
+	err := conn.QueryRow(ctx, "insert into sctl_project(data) values ($1) returning id", NewProjectData(project)).Scan(&projectId)
+	if err != nil {
+		return -1, err
+	}
+
+	return projectId, nil
+}
+
+func (p ProjectsRepository) GetForMemberId(ctx context.Context, memberId int) ([]*projects.Project, error) {
+	conn := p.db.GetConn(ctx)
+	defer conn.Release()
+
+	rows, _ := conn.Query(ctx, "select id, data from sctl_project")
+	projectsArr := make([]*projects.Project, 0)
+
+	for rows.Next() {
+		var (
+			id   int
+			data projectData
+		)
+		err := rows.Scan(&id, &data)
+		if err != nil {
+			return nil, err
+		}
+		projectsArr = append(projectsArr, projects.NewProject(id, data.Name, data.MemberIds, data.AdminIds))
+	}
+
+	return projectsArr, nil
+}

services/entry/pkg/db/postgres/usersRepository.go

@@ -0,0 +1,49 @@
+package postgres
+
+import (
+	"context"
+	"errors"
+	users2 "serverctl/pkg/application/users"
+	"serverctl/pkg/db"
+)
+
+var _ users2.Repository = &usersRepository{}
+
+type usersRepository struct {
+	databasePool *db.Client
+}
+
+func NewUsersRepository(db *db.Client) users2.Repository {
+	return &usersRepository{db}
+}
+
+func (u *usersRepository) Create(ctx context.Context, user *users2.CreateUser) (int, error) {
+	var userId int
+	conn := u.databasePool.GetConn(ctx)
+	defer conn.Release()
+
+	conn.QueryRow(ctx, "INSERT INTO sctl_user(email, password_hash) values ($1, $2) RETURNING id", user.Email, user.PasswordHash).Scan(&userId)
+
+	if userId == 0 {
+		return -1, errors.New("could not insert data into users table")
+	}
+
+	return userId, nil
+}
+
+func (u *usersRepository) GetByEmail(ctx context.Context, email string, passwordHash string) (*users2.User, error) {
+	conn := u.databasePool.GetConn(ctx)
+	defer conn.Release()
+
+	var id int
+	err := conn.QueryRow(ctx, "select id from sctl_user where email = $1 and password_hash = $2", email, passwordHash).Scan(&id)
+	if err != nil {
+		return nil, err
+	}
+
+	if id <= 0 {
+		return nil, errors.New("user with that password doesn't exist")
+	}
+
+	return users2.NewUser(id, email), nil
+}