smm_core/internal/app/server.go

package app

import (
	"context"

	"git.3crabs.ru/save_my_money/smm_core/internal/services/budget"
	"git.3crabs.ru/save_my_money/smm_core/internal/services/category"
	"git.3crabs.ru/save_my_money/smm_core/internal/services/user"
	"git.3crabs.ru/save_my_money/smm_core/internal/services/waste"
	proto "git.3crabs.ru/save_my_money/smm_core/proto"
)

type Server struct {
	proto.UnsafeSmmCoreServer
	categoryService *category.CategoryService
	userService     *user.UserService
	budgetService   *budget.BudgetService
	wasteService    *waste.WasteService
}

func NewServer(
	categoryService *category.CategoryService,
	userService *user.UserService,
	budgetService *budget.BudgetService,
	wasteService *waste.WasteService,
) proto.SmmCoreServer {
	return &Server{
		categoryService: categoryService,
		userService:     userService,
		budgetService:   budgetService,
		wasteService:    wasteService,
	}
}

func (s *Server) Ping(context.Context, *proto.PingReq) (*proto.PingRsp, error) {
	return &proto.PingRsp{}, nil
}

func (s *Server) Login(ctx context.Context, req *proto.LoginReq) (*proto.User, error) {
	user, err := s.userService.Login(
		ctx,
		&user.UserEntity{
			Username: req.Username,
			Password: req.Password,
		},
	)
	if err != nil {
		return nil, err
	}
	return mapUser(user), nil
}

func (s *Server) AddBudget(ctx context.Context, req *proto.AddBudgetReq) (*proto.Budget, error) {
	budget, err := s.budgetService.AddBudget(
		ctx,
		&budget.BudgetEntity{
			Name:         req.Name,
			StartDay:     int(req.StartDay),
			MonthlyLimit: int(req.MonthlyLimit),
		},
	)
	if err != nil {
		return nil, err
	}
	return mapBudget(budget), nil
}

func (s *Server) GetBudgets(ctx context.Context, req *proto.GetBudgetsReq) (*proto.Budgets, error) {
	budgets, err := s.budgetService.GetBudgets(
		ctx,
	)
	if err != nil {
		return nil, err
	}
	res := make([]*proto.Budget, 0, len(budgets))
	for _, budget := range budgets {
		res = append(res, mapBudget(budget))
	}
	return &proto.Budgets{
		Budgets: res,
	}, nil
}

func (s *Server) AddUserToBudget(ctx context.Context, req *proto.AddUserToBudgetReq) (*proto.OK, error) {
	_, err := s.budgetService.AddUserToBudget(
		ctx,
		int(req.BudgetId),
		int(req.UserId),
	)
	if err != nil {
		return nil, err
	}
	return &proto.OK{}, nil
}

func (s *Server) AddCategory(ctx context.Context, req *proto.AddCategoryReq) (*proto.Category, error) {
	category, err := s.categoryService.AddCategory(
		ctx,
		&category.CategoryEntity{
			Name:         req.Name,
			BudgetId:     int(req.BudgetId),
			Favorite:     req.Favorite,
			MonthlyLimit: int(req.MonthlyLimit),
		},
	)
	if err != nil {
		return nil, err
	}
	return mapCategory(category), nil
}

func (s *Server) GetBudgetCategories(ctx context.Context, req *proto.GetBudgetCategoriesReq) (*proto.Categories, error) {
	categories, err := s.budgetService.GetBudgetCategories(
		ctx,
		int(req.BudgetId),
	)
	if err != nil {
		return nil, err
	}
	res := make([]*proto.Category, 0, len(categories))
	for _, category := range categories {
		res = append(res, mapCategory(category))
	}
	return &proto.Categories{
		Categories: res,
	}, nil
}

func (s *Server) AddWaste(ctx context.Context, req *proto.AddWasteReq) (*proto.Waste, error) {
	waste, err := s.wasteService.AddWaste(
		ctx,
		&waste.WasteEntity{
			Name:       req.Name,
			Price:      int(req.Price),
			Amount:     req.Amount,
			CategoryId: int(req.CategoryId),
			BudgetId:   int(req.BudgetId),
		},
	)
	if err != nil {
		return nil, err
	}
	return mapWaste(waste), nil
}

func (s *Server) AddWasteByText(ctx context.Context, req *proto.AddWasteTextReq) (*proto.Waste, error) {
	waste, err := s.wasteService.AddWasteByText(
		ctx,
		&waste.WasteTextEntity{
			Text:       req.Text,
			CategoryId: int(req.CategoryId),
			BudgetId:   int(req.BudgetId),
		},
	)
	if err != nil {
		return nil, err
	}
	return mapWaste(waste), nil
}

// GetCategoriesStat implements proto.SmmCoreServer.
func (s *Server) GetCategoriesStat(context.Context, *proto.GetCategoriesStatReq) (*proto.CategoriesStat, error) {
	panic("unimplemented")
}

// DeleteBudget implements proto.SmmCoreServer.
func (s *Server) DeleteBudget(context.Context, *proto.DeleteBudgetReq) (*proto.Budget, error) {
	panic("unimplemented")
}

// DeleteCategories implements proto.SmmCoreServer.
func (s *Server) DeleteCategories(context.Context, *proto.DeleteCategoriesReq) (*proto.Category, error) {
	panic("unimplemented")
}

// DeleteWaste implements proto.SmmCoreServer.
func (s *Server) DeleteWaste(context.Context, *proto.DeleteWasteReq) (*proto.Waste, error) {
	panic("unimplemented")
}

// GetBudgetUsers implements proto.SmmCoreServer.
func (s *Server) GetBudgetUsers(context.Context, *proto.GetBudgetUsersReq) (*proto.Users, error) {
	panic("unimplemented")
}

// RemoveUserFromBudget implements proto.SmmCoreServer.
func (s *Server) RemoveUserFromBudget(context.Context, *proto.RemoveUserFromBudgetReq) (*proto.Budget, error) {
	panic("unimplemented")
}

// UpdateBudget implements proto.SmmCoreServer.
func (s *Server) UpdateBudget(context.Context, *proto.UpdateBudgetReq) (*proto.Budget, error) {
	panic("unimplemented")
}

// UpdateCategory implements proto.SmmCoreServer.
func (s *Server) UpdateCategory(context.Context, *proto.UpdateCategoryReq) (*proto.Category, error) {
	panic("unimplemented")
}