Initial commit

internal/application/commands/create_image_command.go

@@ -0,0 +1,5 @@
+package commands
+
+type CreateImageCommand struct {
+	Path string
+}

internal/application/commands/create_post_command.go

@@ -0,0 +1,10 @@
+package commands
+
+import "github.com/google/uuid"
+
+type CreatePostCommand struct {
+	UserId      uuid.UUID
+	Title       string
+	Description string
+	Content     string
+}

internal/application/commands/create_posts_command.go

@@ -0,0 +1,8 @@
+package commands
+
+import "github.com/google/uuid"
+
+type CreatePostsCommand struct {
+	PostId uuid.UUID
+	UserId uuid.UUID
+}

internal/application/commands/create_user_command.go

@@ -0,0 +1,6 @@
+package commands
+
+type CreateUserCommand struct {
+	Username string
+	Password string
+}

internal/application/commands/delete_image_command.go

@@ -0,0 +1,7 @@
+package commands
+
+import "github.com/google/uuid"
+
+type DeleteImageCommand struct {
+	Id uuid.UUID
+}

internal/application/commands/delete_post_command.go

@@ -0,0 +1,7 @@
+package commands
+
+import "github.com/google/uuid"
+
+type DeletePostCommand struct {
+	Id uuid.UUID
+}

internal/application/commands/delete_posts_command.go

@@ -0,0 +1,7 @@
+package commands
+
+import "github.com/google/uuid"
+
+type DeletePostsCommand struct {
+	Id uuid.UUID
+}

internal/application/commands/delete_user_command.go

@@ -0,0 +1,7 @@
+package commands
+
+import "github.com/google/uuid"
+
+type DeleteUserCommand struct {
+	Id uuid.UUID
+}

internal/application/commands/update_post_command.go

@@ -0,0 +1,10 @@
+package commands
+
+import "github.com/google/uuid"
+
+type UpdatePostCommand struct {
+	Id          uuid.UUID
+	Title       string
+	Description string
+	Content     string
+}

internal/application/commands/update_user_command.go

@@ -0,0 +1,9 @@
+package commands
+
+import "github.com/google/uuid"
+
+type UpdateUserCommand struct {
+	Id       uuid.UUID
+	Username string
+	Password string
+}

internal/application/common/image_result.go

@@ -0,0 +1,8 @@
+package common
+
+import "github.com/google/uuid"
+
+type ImageResult struct {
+	Id   uuid.UUID
+	Path string
+}

internal/application/common/post_result.go

@@ -0,0 +1,21 @@
+package common
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type PostResult struct {
+	Id          uuid.UUID
+	UserId      uuid.UUID
+	Title       string
+	Description string
+	Content     string
+	CreatedAt   time.Time
+	UpdatedAt   time.Time
+}
+
+type PostResultList struct {
+	Result []*PostResult
+}

internal/application/common/posts_result.go

@@ -0,0 +1,13 @@
+package common
+
+import "github.com/google/uuid"
+
+type PostsResult struct {
+	Id     uuid.UUID
+	UserId uuid.UUID
+	PostId uuid.UUID
+}
+
+type PostsResultList struct {
+	Result []*PostsResult
+}

internal/application/common/user_result.go

@@ -0,0 +1,13 @@
+package common
+
+import "github.com/google/uuid"
+
+type UserResult struct {
+	Id       uuid.UUID
+	UserName string
+	Password string
+}
+
+type UserResultList struct {
+	Result []*UserResult
+}

internal/application/interfaces/images_service.go

@@ -0,0 +1,13 @@
+package interfaces
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+)
+
+type ImagesService interface {
+	Create(commands.CreateImageCommand) (*common.ImageResult, error)
+	FindById(queries.ImageFindByIdQuery) (*queries.ImageFindByIdResult, error)
+	Delete(commands.DeleteImageCommand) error
+}

internal/application/interfaces/post_service.go

@@ -0,0 +1,16 @@
+package interfaces
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+)
+
+type PostService interface {
+	Create(commands.CreatePostCommand) (*common.PostResult, error)
+	FindById(queries.PostFindByIdQuery) (*queries.PostFindByIdResult, error)
+	FindAllByUserName(queries.PostFindAllByUserNameQuery) (*queries.PostFindAllByUserNameResult, error)
+	GetAll() (*queries.PostGetAllResult, error)
+	Update(commands.UpdatePostCommand) (*common.PostResult, error)
+	Delete(commands.DeletePostCommand) error
+}

internal/application/interfaces/posts_service.go

@@ -0,0 +1,16 @@
+package interfaces
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+)
+
+type PostsService interface {
+	Create(commands.CreatePostsCommand) (*common.PostsResult, error)
+	FindByUserId(queries.PostsFindByUserIdQuery) (*queries.PostsFindByUserIdResult, error)
+	FindByPostId(queries.PostsFindByPostIdQuery) (*queries.PostsFindByPostIdResult, error)
+	FindAllByUserId(queries.PostsFindByUserIdQuery) (*queries.PostsFindAllByUserIdResult, error)
+	GetAll() (queries.PostsGetAllResult, error)
+	Delete(commands.DeletePostsCommand) error
+}

internal/application/interfaces/user_service.go

@@ -0,0 +1,16 @@
+package interfaces
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+)
+
+type UserService interface {
+	Create(commands.CreateUserCommand) (*common.UserResult, error)
+	FindById(queries.UserFindByIdQuery) (*queries.UserFindByIdResult, error)
+	FindByName(queries.UserFindByNameQuery) (*queries.UserFindByNameResult, error)
+	GetAll() (*queries.UserGetAllResult, error)
+	Update(commands.UpdateUserCommand) (*common.UserResult, error)
+	Delete(commands.DeleteUserCommand) error
+}

internal/application/mapper/image_result.go

@@ -0,0 +1,20 @@
+package mapper
+
+import (
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+)
+
+func CreateImageResultFromEntity(entity *entities.Images) *common.ImageResult {
+	return &common.ImageResult{
+		Id:   entity.Id,
+		Path: entity.Path,
+	}
+}
+
+func CreateImageFindByIdResultFromEntity(entity *entities.Images) *queries.ImageFindByIdResult {
+	return &queries.ImageFindByIdResult{
+		Result: CreateImageResultFromEntity(entity),
+	}
+}

internal/application/mapper/post_result.go

@@ -0,0 +1,47 @@
+package mapper
+
+import (
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+)
+
+func CreatePostResultFromEntity(entity *entities.Post) *common.PostResult {
+	return &common.PostResult{
+		Id:          entity.Id,
+		UserId:      entity.UserId,
+		Title:       entity.Title,
+		Description: entity.Description,
+		Content:     entity.Content,
+		CreatedAt:   entity.CreatedAt,
+		UpdatedAt:   entity.UpdatedAt,
+	}
+}
+
+func CreatePostResultListFromEntity(entity_list []*entities.Post) *common.PostResultList {
+	var result common.PostResultList
+
+	for _, e := range entity_list {
+		result.Result = append(result.Result, CreatePostResultFromEntity(e))
+	}
+
+	return &result
+}
+
+func CreatePostFindByIdResultFromEntity(entity entities.Post) *queries.PostFindByIdResult {
+	return &queries.PostFindByIdResult{
+		Result: CreatePostResultFromEntity(&entity),
+	}
+}
+
+func CreatePostFindAllByUserNameResult(entity []*entities.Post) *queries.PostFindAllByUserNameResult {
+	return &queries.PostFindAllByUserNameResult{
+		Result: CreatePostResultListFromEntity(entity),
+	}
+}
+
+func CreatePostGetAllResult(entity_list []*entities.Post) *queries.PostGetAllResult {
+	return &queries.PostGetAllResult{
+		Result: CreatePostResultListFromEntity(entity_list),
+	}
+}

internal/application/mapper/posts_result.go

@@ -0,0 +1,48 @@
+package mapper
+
+import (
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+)
+
+func CreatePostsResultFromEntity(entity *entities.Posts) *common.PostsResult {
+	return &common.PostsResult{
+		Id:     entity.Id,
+		UserId: entity.UserId,
+		PostId: entity.PostId,
+	}
+}
+
+func CreatePostsResultListFromEntityList(entity_list []*entities.Posts) *common.PostsResultList {
+	var result common.PostsResultList
+	for _, e := range entity_list {
+		result.Result = append(result.Result, CreatePostsResultFromEntity(e))
+	}
+
+	return &result
+}
+
+func CreatePostsFindByUserIdResultFromEntity(entity *entities.Posts) *queries.PostsFindByUserIdResult {
+	return &queries.PostsFindByUserIdResult{
+		Result: CreatePostsResultFromEntity(entity),
+	}
+}
+
+func CreatePostsFindByPostIdResultFromEntity(entity *entities.Posts) *queries.PostsFindByPostIdResult {
+	return &queries.PostsFindByPostIdResult{
+		Result: CreatePostsResultFromEntity(entity),
+	}
+}
+
+func CreatePostsFindAllByUserIdResultFromEntity(entity_list []*entities.Posts) *queries.PostsFindAllByUserIdResult {
+	return &queries.PostsFindAllByUserIdResult{
+		Result: CreatePostsResultListFromEntityList(entity_list),
+	}
+}
+
+func CreatePostsGetAllResultFromEntity(entity_list []*entities.Posts) *queries.PostsGetAllResult {
+	return &queries.PostsGetAllResult{
+		Result: CreatePostsResultListFromEntityList(entity_list),
+	}
+}

internal/application/mapper/user_result.go

@@ -0,0 +1,43 @@
+package mapper
+
+import (
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+)
+
+func CreateUserResultFromEntity(entity *entities.User) *common.UserResult {
+	return &common.UserResult{
+		Id:       entity.Id,
+		UserName: entity.UserName,
+		Password: entity.Password,
+	}
+}
+
+func CreateUserResultListFromEntity(entityList []*entities.User) *common.UserResultList {
+	var result common.UserResultList
+
+	for _, e := range entityList {
+		result.Result = append(result.Result, CreateUserResultFromEntity(e))
+	}
+
+	return &result
+}
+
+func CreateUserFindByIdResultFromEntity(entity *entities.User) *queries.UserFindByIdResult {
+	return &queries.UserFindByIdResult{
+		Result: CreateUserResultFromEntity(entity),
+	}
+}
+
+func CreateUserFindByNameResultFromEntity(entity *entities.User) *queries.UserFindByNameResult {
+	return &queries.UserFindByNameResult{
+		Result: CreateUserResultFromEntity(entity),
+	}
+}
+
+func CreateUserGetAllResultFromEntity(entity_list []*entities.User) *queries.UserGetAllResult {
+	return &queries.UserGetAllResult{
+		Result: CreateUserResultListFromEntity(entity_list),
+	}
+}

internal/application/queries/image_find_by_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type ImageFindByIdQuery struct {
+	Id uuid.UUID
+}
+
+type ImageFindByIdResult struct {
+	Result *common.ImageResult
+}

internal/application/queries/post_find_all_by_user_name.go

@@ -0,0 +1,11 @@
+package queries
+
+import "58team_blog/internal/application/common"
+
+type PostFindAllByUserNameQuery struct {
+	UserName string
+}
+
+type PostFindAllByUserNameResult struct {
+	Result *common.PostResultList
+}

internal/application/queries/post_find_by_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type PostFindByIdQuery struct {
+	Id uuid.UUID
+}
+
+type PostFindByIdResult struct {
+	Result *common.PostResult
+}

internal/application/queries/post_get_all.go

@@ -0,0 +1,7 @@
+package queries
+
+import "58team_blog/internal/application/common"
+
+type PostGetAllResult struct {
+	Result *common.PostResultList
+}

internal/application/queries/posts_find_all_by_user_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type PostsFindAllByUserIdQuery struct {
+	UserId uuid.UUID
+}
+
+type PostsFindAllByUserIdResult struct {
+	Result *common.PostsResultList
+}

internal/application/queries/posts_find_by_post_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type PostsFindByPostIdQuery struct {
+	PostId uuid.UUID
+}
+
+type PostsFindByPostIdResult struct {
+	Result *common.PostsResult
+}

internal/application/queries/posts_find_by_user_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type PostsFindByUserIdQuery struct {
+	UserId uuid.UUID
+}
+
+type PostsFindByUserIdResult struct {
+	Result *common.PostsResult
+}

internal/application/queries/posts_get_all.go

@@ -0,0 +1,7 @@
+package queries
+
+import "58team_blog/internal/application/common"
+
+type PostsGetAllResult struct {
+	Result *common.PostsResultList
+}

internal/application/queries/user_find_by_id.go

@@ -0,0 +1,15 @@
+package queries
+
+import (
+	"58team_blog/internal/application/common"
+
+	"github.com/google/uuid"
+)
+
+type UserFindByIdQuery struct {
+	Id uuid.UUID
+}
+
+type UserFindByIdResult struct {
+	Result *common.UserResult
+}

internal/application/queries/user_find_by_name.go

@@ -0,0 +1,11 @@
+package queries
+
+import "58team_blog/internal/application/common"
+
+type UserFindByNameQuery struct {
+	Name string
+}
+
+type UserFindByNameResult struct {
+	Result *common.UserResult
+}

internal/application/queries/user_get_all.go

@@ -0,0 +1,7 @@
+package queries
+
+import "58team_blog/internal/application/common"
+
+type UserGetAllResult struct {
+	Result *common.UserResultList
+}

internal/application/services/images_service.go

@@ -0,0 +1,72 @@
+package services
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/mapper"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+	"58team_blog/internal/domain/repository"
+	"fmt"
+)
+
+type ImagesService struct {
+	repo repository.ImagesRepository
+}
+
+func NewImagesService(repo repository.ImagesRepository) ImagesService {
+	return ImagesService{
+		repo: repo,
+	}
+}
+
+func (s *ImagesService) Create(cmd commands.CreateImageCommand) (*common.ImageResult, error) {
+	entity, err := entities.CreateImage(cmd.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	if err := s.repo.Create(&entity); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateImageResultFromEntity(&entity)
+
+	return result, nil
+}
+
+func (s *ImagesService) FindById(query queries.ImageFindByIdQuery) (*queries.ImageFindByIdResult, error) {
+	entity, err := s.repo.FindById(query.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateImageFindByIdResultFromEntity(entity)
+
+	return result, nil
+}
+
+func (s *ImagesService) Delete(cmd commands.DeleteImageCommand) error {
+	entity, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return fmt.Errorf("Image delete error: %s", err)
+	}
+
+	if err := entity.Validate(); err != nil {
+		return err
+	}
+
+	if err := s.repo.Delete(entity.Id); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/application/services/post_service.go

@@ -0,0 +1,130 @@
+package services
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/mapper"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+	"58team_blog/internal/domain/repository"
+	"time"
+)
+
+type PostService struct {
+	repo         repository.PostRepository
+	postsService PostsService
+}
+
+func CreatePostService(repo repository.PostRepository, postsService PostsService) PostService {
+	return PostService{
+		repo:         repo,
+		postsService: postsService,
+	}
+}
+
+func (s *PostService) Create(cmd commands.CreatePostCommand) (*common.PostResult, error) {
+	entity, err := entities.CreatePost(cmd.UserId, cmd.Title, cmd.Description, cmd.Content)
+	if err != nil {
+		return nil, err
+	}
+
+	post, err := s.repo.Create(&entity)
+	if err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostResultFromEntity(post)
+
+	return result, nil
+}
+
+func (s *PostService) FindById(query queries.PostFindByIdQuery) (*queries.PostFindByIdResult, error) {
+	post, err := s.repo.FindById(query.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := post.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostFindByIdResultFromEntity(*post)
+
+	return result, nil
+}
+
+func (s *PostService) FindAllByUserName(query queries.PostFindAllByUserNameQuery) (*queries.PostFindAllByUserNameResult, error) {
+	posts, err := s.repo.FindAllByUserName(query.UserName)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, p := range posts {
+		if err := p.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	result := mapper.CreatePostFindAllByUserNameResult(posts)
+
+	return result, nil
+}
+
+func (s *PostService) GetAll() (*queries.PostGetAllResult, error) {
+	posts, err := s.repo.GetAll()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, p := range posts {
+		if err := p.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	result := mapper.CreatePostGetAllResult(posts)
+
+	return result, nil
+}
+
+func (s *PostService) Update(cmd commands.UpdatePostCommand) (*common.PostResult, error) {
+	post, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := post.Validate(); err != nil {
+		return nil, err
+	}
+
+	post.Title = cmd.Title
+	post.Description = cmd.Description
+	post.Content = cmd.Content
+	post.UpdatedAt = time.Now()
+
+	if err := post.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostResultFromEntity(post)
+
+	return result, nil
+}
+
+func (s *PostService) Delete(cmd commands.DeletePostCommand) error {
+	post, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return err
+	}
+
+	if err := post.Validate(); err != nil {
+		return err
+	}
+
+	err = s.repo.Delete(cmd.Id)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/application/services/posts_service.go

@@ -0,0 +1,141 @@
+package services
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/mapper"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+	"58team_blog/internal/domain/repository"
+	"errors"
+	"fmt"
+)
+
+type PostsService struct {
+	repo repository.PostsRepository
+}
+
+func CreatePostsService(repo repository.PostsRepository) PostsService {
+	return PostsService{
+		repo: repo,
+	}
+}
+
+func (s *PostsService) Create(cmd commands.CreatePostsCommand) (*common.PostsResult, error) {
+	if user, err := s.repo.FindByPostId(cmd.PostId); user != nil {
+		if err != nil {
+			return nil, err
+		}
+
+		return nil, errors.New("Posts already exists")
+	}
+
+	entity, err := entities.CreatePosts(cmd.UserId, cmd.PostId)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostsResultFromEntity(&entity)
+
+	return result, nil
+}
+
+func (s *PostsService) FindByUserId(query queries.PostsFindByUserIdQuery) (*queries.PostsFindByUserIdResult, error) {
+	entity, err := s.repo.FindByUserId(query.UserId)
+	if err != nil {
+		return nil, err
+	}
+
+	if entity == nil {
+		return nil, errors.New("Posts not found")
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostsFindByUserIdResultFromEntity(entity)
+
+	return result, nil
+}
+
+func (s *PostsService) FindByPostId(query queries.PostsFindByPostIdQuery) (*queries.PostsFindByPostIdResult, error) {
+	entity, err := s.repo.FindByPostId(query.PostId)
+	if err != nil {
+		return nil, err
+	}
+
+	if entity == nil {
+		return nil, errors.New("Posts not found")
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreatePostsFindByPostIdResultFromEntity(entity)
+
+	return result, nil
+}
+
+func (s *PostsService) FindAllByUserId(query queries.PostsFindByUserIdQuery) (*queries.PostsFindAllByUserIdResult, error) {
+	entities, err := s.repo.FindAllByUserId(query.UserId)
+	if err != nil {
+		return nil, err
+	}
+
+	if entities == nil {
+		return nil, fmt.Errorf("No posts owned by user: %s", query.UserId.String())
+	}
+
+	for _, e := range entities {
+		if err := e.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	result := mapper.CreatePostsFindAllByUserIdResultFromEntity(entities)
+
+	return result, nil
+}
+
+func (s *PostsService) GetAll() (*queries.PostsGetAllResult, error) {
+	entities, err := s.repo.GetAll()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, e := range entities {
+		if err := e.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	result := mapper.CreatePostsGetAllResultFromEntity(entities)
+	return result, nil
+}
+
+func (s *PostsService) Delete(cmd commands.DeletePostsCommand) error {
+	entity, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return err
+	}
+
+	if entity == nil {
+		return fmt.Errorf("Posts row not found: %s", cmd.Id)
+	}
+
+	if err := entity.Validate(); err != nil {
+		return err
+	}
+
+	if err := s.repo.Delete(cmd.Id); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/application/services/user_service.go

@@ -0,0 +1,145 @@
+package services
+
+import (
+	"58team_blog/internal/application/commands"
+	"58team_blog/internal/application/common"
+	"58team_blog/internal/application/mapper"
+	"58team_blog/internal/application/queries"
+	"58team_blog/internal/domain/entities"
+	"58team_blog/internal/domain/repository"
+	"errors"
+	"fmt"
+)
+
+type UserService struct {
+	repo repository.UsersRepository
+}
+
+func NewUserService(repo repository.UsersRepository) UserService {
+	return UserService{
+		repo: repo,
+	}
+}
+
+func (s *UserService) Create(cmd commands.CreateUserCommand) (*common.UserResult, error) {
+	// Check user with given name exists
+	{
+		user, err := s.repo.FindByName(cmd.Username)
+		if err != nil {
+			return nil, err
+		}
+
+		if user != nil {
+			return nil, fmt.Errorf("User: %s already exists", user.UserName)
+		}
+	}
+
+	// Create new user
+	user, err := entities.CreateUser(cmd.Username, cmd.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := user.Validate(); err != nil {
+		return nil, err
+	}
+
+	entity, err := s.repo.Create(&user)
+	if err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateUserResultFromEntity(entity)
+
+	return result, nil
+}
+
+func (s *UserService) FindById(query queries.UserFindByIdQuery) (*queries.UserFindByIdResult, error) {
+	entity, err := s.repo.FindById(query.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateUserFindByIdResultFromEntity(entity)
+
+	return result, nil
+}
+
+func (s *UserService) FindByName(query queries.UserFindByNameQuery) (*queries.UserFindByNameResult, error) {
+	entity, err := s.repo.FindByName(query.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateUserFindByNameResultFromEntity(entity)
+	return result, nil
+}
+
+func (s *UserService) GetAll() (*queries.UserGetAllResult, error) {
+	entityList, err := s.repo.GetAll()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, e := range entityList {
+		if err := e.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	result := mapper.CreateUserGetAllResultFromEntity(entityList)
+	return result, nil
+}
+
+func (s *UserService) Update(cmd commands.UpdateUserCommand) (*common.UserResult, error) {
+	entity, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	if cmd.Username != entity.UserName {
+		return nil, errors.New("You cannot change user name")
+	}
+
+	entity.Password = cmd.Password
+
+	if err := entity.Validate(); err != nil {
+		return nil, err
+	}
+
+	if err := s.repo.Update(entity); err != nil {
+		return nil, err
+	}
+
+	result := mapper.CreateUserResultFromEntity(entity)
+	return result, nil
+}
+
+func (s *UserService) Delete(cmd commands.DeleteUserCommand) error {
+	entity, err := s.repo.FindById(cmd.Id)
+	if err != nil {
+		return err
+	}
+
+	if err := entity.Validate(); err != nil {
+		return err
+	}
+
+	if err := s.repo.Delete(entity.Id); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/domain/entities/images.go

@@ -0,0 +1,33 @@
+package entities
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+const ImagesTable = "images"
+
+type Images struct {
+	Id   uuid.UUID `db:"id"`
+	Path string    `db:"path"`
+}
+
+func CreateImage(path string) (image Images, err error) {
+	image = Images{
+		Id:   uuid.New(),
+		Path: path,
+	}
+
+	err = image.Validate()
+
+	return
+}
+
+func (i *Images) Validate() error {
+	if i.Path == "" {
+		return errors.New("Empty image.path")
+	}
+
+	return nil
+}

internal/domain/entities/post.go

@@ -0,0 +1,68 @@
+package entities
+
+import (
+	"errors"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+const PostTable = "post"
+
+type Post struct {
+	Id          uuid.UUID `db:"id"`
+	UserId      uuid.UUID `db:"user_id"`
+	Title       string    `db:"title"`
+	Description string    `db:"description"`
+	Content     string    `db:"content"`
+	CreatedAt   time.Time `db:"createdAt"`
+	UpdatedAt   time.Time `db:"updatedAt"`
+}
+
+func CreatePost(userId uuid.UUID, title string, description string, content string) (post Post, err error) {
+	post = Post{
+		Id:          uuid.New(),
+		UserId:      userId,
+		Title:       title,
+		Description: description,
+		Content:     content,
+		CreatedAt:   time.Now(),
+		UpdatedAt:   time.Now(),
+	}
+
+	err = post.Validate()
+
+	return
+}
+
+func (p *Post) Validate() error {
+	if err := uuid.Validate(p.Id.String()); err != nil {
+		return errors.New("Empty post.id")
+	}
+
+	if err := uuid.Validate(p.UserId.String()); err != nil {
+		return errors.New("Empty post.userId")
+	}
+
+	if p.Title == "" {
+		return errors.New("Empty post.title")
+	}
+
+	if p.Description == "" {
+		return errors.New("Empty post.description")
+	}
+
+	if p.Content == "" {
+		return errors.New("Empty post.content path")
+	}
+
+	if p.CreatedAt.IsZero() {
+		return errors.New("Empty post.createdAt")
+	}
+
+	if p.UpdatedAt.IsZero() {
+		return errors.New("Empty post.updatedAt")
+	}
+
+	return nil
+}

internal/domain/entities/posts.go

@@ -0,0 +1,43 @@
+package entities
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+const PostsTable = "posts"
+
+type Posts struct {
+	Id     uuid.UUID `db:"id"`
+	UserId uuid.UUID `db:"user_id"`
+	PostId uuid.UUID `db:"post_id"`
+}
+
+func CreatePosts(userId uuid.UUID, postId uuid.UUID) (posts Posts, err error) {
+	posts = Posts{
+		Id:     uuid.New(),
+		UserId: userId,
+		PostId: postId,
+	}
+
+	err = posts.Validate()
+
+	return
+}
+
+func (p *Posts) Validate() error {
+	if err := uuid.Validate(p.Id.String()); err != nil {
+		return errors.New("Invalid posts.id")
+	}
+
+	if err := uuid.Validate(p.UserId.String()); err != nil {
+		return errors.New("Invalid posts.userId")
+	}
+
+	if err := uuid.Validate(p.PostId.String()); err != nil {
+		return errors.New("Invalid posts.postId")
+	}
+
+	return nil
+}

internal/domain/entities/user.go

@@ -0,0 +1,42 @@
+package entities
+
+import (
+	"errors"
+
+	"github.com/google/uuid"
+)
+
+const UserTable = "users"
+
+type User struct {
+	Id       uuid.UUID `db:"id"`
+	UserName string    `db:"username"`
+	Password string    `db:"password"`
+}
+
+func CreateUser(userName string, password string) (user User, err error) {
+	user = User{
+		Id:       uuid.New(),
+		UserName: userName,
+		Password: password,
+	}
+
+	err = user.Validate()
+
+	return
+}
+
+func (u *User) Validate() error {
+	if err := uuid.Validate(u.Id.String()); err != nil {
+		return errors.New("Invalid user.id")
+	}
+	if u.UserName == "" {
+		return errors.New("Empty user.name")
+	}
+
+	if u.Password == "" {
+		return errors.New("Empty user.password")
+	}
+
+	return nil
+}

internal/domain/repository/images_repo.go

@@ -0,0 +1,13 @@
+package repository
+
+import (
+	"58team_blog/internal/domain/entities"
+
+	"github.com/google/uuid"
+)
+
+type ImagesRepository interface {
+	Create(*entities.Images) error
+	FindById(uuid.UUID) (*entities.Images, error)
+	Delete(uuid.UUID) error
+}

internal/domain/repository/post_repo.go

@@ -0,0 +1,16 @@
+package repository
+
+import (
+	"58team_blog/internal/domain/entities"
+
+	"github.com/google/uuid"
+)
+
+type PostRepository interface {
+	Create(*entities.Post) (*entities.Post, error)
+	FindById(uuid.UUID) (*entities.Post, error)
+	FindAllByUserName(string) ([]*entities.Post, error)
+	GetAll() ([]*entities.Post, error)
+	Update(*entities.Post) error
+	Delete(uuid.UUID) error
+}

internal/domain/repository/posts_repo.go

@@ -0,0 +1,17 @@
+package repository
+
+import (
+	"58team_blog/internal/domain/entities"
+
+	"github.com/google/uuid"
+)
+
+type PostsRepository interface {
+	Create(*entities.Posts) (*entities.Posts, error)
+	FindById(uuid.UUID) (*entities.Posts, error)
+	FindByPostId(uuid.UUID) (*entities.Posts, error)
+	FindByUserId(uuid.UUID) (*entities.Posts, error)
+	FindAllByUserId(uuid.UUID) ([]*entities.Posts, error)
+	GetAll() ([]*entities.Posts, error)
+	Delete(uuid.UUID) error
+}

internal/domain/repository/user_repo.go

@@ -0,0 +1,16 @@
+package repository
+
+import (
+	"58team_blog/internal/domain/entities"
+
+	"github.com/google/uuid"
+)
+
+type UsersRepository interface {
+	Create(*entities.User) (*entities.User, error)
+	FindById(uuid.UUID) (*entities.User, error)
+	FindByName(string) (*entities.User, error)
+	GetAll() ([]*entities.User, error)
+	Update(*entities.User) error
+	Delete(uuid.UUID) error
+}

internal/infrastructure/config.go

@@ -0,0 +1,41 @@
+package infrastructure
+
+import (
+	"github.com/creasty/defaults"
+	"github.com/spf13/viper"
+)
+
+type Config struct {
+	DBUser        string `mapstructure:"db-user" default:"userpg"`
+	DBName        string `mapstructure:"db-name" default:"58blog"`
+	DBPass        string `mapstructure:"db-password" default:"1205"`
+	DBHost        string `mapstructure:"db-host" default:"localhost"`
+	DBPort        string `mapstructure:"db-port" default:"5432"`
+	AdminName     string `mapstructure:"admin_name" default:"muts"`
+	AdminPassword string `mapstructure:"admin_pass" default:"1205"`
+	ImagesPath    string `mapstructure:"images_path" default:"./images/"`
+	PostsPath     string `mapstructure:"posts_path" default:"./posts/"`
+}
+
+func LoadConfig() (config Config, err error) {
+	config = Config{}
+	if err = defaults.Set(config); err != nil {
+		return
+	}
+
+	viper.SetConfigName("config")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath(".")
+	viper.AddConfigPath("/etc/58team_blog/")
+	viper.AddConfigPath("/58team_blog/cfgs/")
+
+	if err = viper.ReadInConfig(); err != nil {
+		return
+	}
+
+	if err = viper.Unmarshal(&config); err != nil {
+		return
+	}
+
+	return
+}

internal/infrastructure/db.go

@@ -0,0 +1,19 @@
+package infrastructure
+
+import (
+	"fmt"
+
+	"github.com/jmoiron/sqlx"
+)
+
+type Database struct {
+	connection *sqlx.DB
+}
+
+func DatabaseInit(config Config) (db Database, err error) {
+	db = Database{}
+	db_setup := fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s", config.DBUser, config.DBPass, config.DBHost, config.DBPort, config.DBName)
+	db.connection, err = sqlx.Connect("postgres", db_setup)
+
+	return
+}

internal/infrastructure/infrastructure.go

@@ -0,0 +1,20 @@
+package infrastructure
+
+type Infrastructure struct {
+	Config Config
+	Db     Database
+}
+
+func InfrastructureInit() (infra Infrastructure, err error) {
+	infra = Infrastructure{}
+
+	if infra.Config, err = LoadConfig(); err != nil {
+		return
+	}
+
+	if infra.Db, err = DatabaseInit(infra.Config); err != nil {
+		return
+	}
+
+	return
+}

internal/infrastructure/jaeger.go

@@ -0,0 +1 @@
+package infrastructure

internal/interfaces/api/images_controller.go

@@ -0,0 +1 @@
+package api

internal/interfaces/api/post_controller.go

@@ -0,0 +1 @@
+package api

internal/interfaces/api/user_controller.go

@@ -0,0 +1 @@
+package api

internal/interfaces/route.go

@@ -0,0 +1 @@
+package interfaces