apksel-dev/apskel-pos-backend
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init project

Browse Source
This commit is contained in:
aditya.siregar
2024-05-28 14:14:55 +07:00
commit 67f1dbc850
141 changed files with 16879 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/services/auth/init.go
+48
View File
@@ -0,0 +1,48 @@
package auth
import (
"context"
"furtuna-be/internal/entity"
"go.uber.org/zap"
"furtuna-be/internal/common/errors"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/repository"
)
type AuthServiceImpl struct {
authRepo repository.Auth
crypto repository.Crypto
}
func New(authRepo repository.Auth, crypto repository.Crypto) *AuthServiceImpl {
return &AuthServiceImpl{
authRepo: authRepo,
crypto: crypto,
}
}
func (u *AuthServiceImpl) AuthenticateUser(ctx context.Context, email, password string) (*entity.AuthenticateUser, error) {
user, err := u.authRepo.CheckExistsUserAccount(ctx, email)
if err != nil {
logger.ContextLogger(ctx).Error("error when get user", zap.Error(err))
return nil, errors.ErrorInternalServer
}
if user == nil {
return nil, errors.ErrorUserIsNotFound
}
if ok := u.crypto.CompareHashAndPassword(user.Password, password); !ok {
return nil, errors.ErrorUserInvalidLogin
}
signedToken, err := u.crypto.GenerateJWT(user.ToUser())
if err != nil {
return nil, err
}
return user.ToUserAuthenticate(signedToken), nil
}
internal/services/branch/branch.go
+89
View File
@@ -0,0 +1,89 @@
package branch
import (
"context"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"go.uber.org/zap"
)
type BranchService struct {
repo repository.Branch
}
func NewBranchService(repo repository.Branch) *BranchService {
return &BranchService{
repo: repo,
}
}
func (s *BranchService) Create(ctx mycontext.Context, branchReq *entity.Branch) (*entity.Branch, error) {
branchDB := branchReq.ToBranchDB()
branchDB.CreatedBy = ctx.RequestedBy()
branchDB, err := s.repo.CreateBranch(ctx, branchDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create branch", zap.Error(err))
return nil, err
}
return branchDB.ToBranch(), nil
}
func (s *BranchService) Update(ctx mycontext.Context, id int64, branchReq *entity.Branch) (*entity.Branch, error) {
existingBranch, err := s.repo.GetBranchByID(ctx, id)
if err != nil {
return nil, err
}
existingBranch.ToUpdatedBranch(ctx.RequestedBy(), *branchReq)
updatedBranchDB, err := s.repo.UpdateBranch(ctx, existingBranch.ToBranchDB())
if err != nil {
logger.ContextLogger(ctx).Error("error when update branch", zap.Error(err))
return nil, err
}
return updatedBranchDB.ToBranch(), nil
}
func (s *BranchService) GetByID(ctx context.Context, id int64) (*entity.Branch, error) {
branchDB, err := s.repo.GetBranchByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get branch by id", zap.Error(err))
return nil, err
}
return branchDB.ToBranch(), nil
}
func (s *BranchService) GetAll(ctx context.Context, search entity.BranchSearch) ([]*entity.Branch, int, error) {
branches, total, err := s.repo.GetAllBranches(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all branches", zap.Error(err))
return nil, 0, err
}
return branches.ToBranchList(), total, nil
}
func (s *BranchService) Delete(ctx mycontext.Context, id int64) error {
branchDB, err := s.repo.GetBranchByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get branch by id", zap.Error(err))
return err
}
branchDB.SetDeleted(ctx.RequestedBy())
_, err = s.repo.UpdateBranch(ctx, branchDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when update branch", zap.Error(err))
return err
}
return nil
}
internal/services/event/event.go
+88
View File
@@ -0,0 +1,88 @@
package event
import (
"context"
"go.uber.org/zap"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
)
type EventService struct {
repo repository.Event
}
func NewEventService(repo repository.Event) *EventService {
return &EventService{
repo: repo,
}
}
func (s *EventService) Create(ctx context.Context, eventReq *entity.Event) (*entity.Event, error) {
eventDB := eventReq.ToEventDB()
eventDB, err := s.repo.CreateEvent(ctx, eventDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create event", zap.Error(err))
return nil, err
}
return eventDB.ToEvent(), nil
}
func (s *EventService) Update(ctx context.Context, id int64, eventReq *entity.Event) (*entity.Event, error) {
existingEvent, err := s.repo.GetEventByID(ctx, id)
if err != nil {
return nil, err
}
existingEvent.ToUpdatedEvent(*eventReq)
updatedEventDB, err := s.repo.UpdateEvent(ctx, existingEvent.ToEventDB())
if err != nil {
logger.ContextLogger(ctx).Error("error when update event", zap.Error(err))
return nil, err
}
return updatedEventDB.ToEvent(), nil
}
func (s *EventService) GetByID(ctx context.Context, id int64) (*entity.Event, error) {
eventDB, err := s.repo.GetEventByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get event by id", zap.Error(err))
return nil, err
}
return eventDB.ToEvent(), nil
}
func (s *EventService) GetAll(ctx context.Context, search entity.EventSearch) ([]*entity.Event, int, error) {
events, total, err := s.repo.GetAllEvents(ctx, search.Name, search.Limit, search.Offset)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all events", zap.Error(err))
return nil, 0, err
}
return events.ToEventList(), total, nil
}
func (s *EventService) Delete(ctx context.Context, id int64) error {
eventDB, err := s.repo.GetEventByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get event by id", zap.Error(err))
return err
}
eventDB.SetDeleted()
_, err = s.repo.UpdateEvent(ctx, eventDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when update event", zap.Error(err))
return err
}
return nil
}
internal/services/order/order.go
+147
View File
@@ -0,0 +1,147 @@
package order
import (
"context"
"fmt"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/constants/order"
"furtuna-be/internal/constants/transaction"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"go.uber.org/zap"
)
type OrderService struct {
repo repository.Order
prodRepo repository.Product
studioRepo repository.Studio
}
func NewOrderService(repo repository.Order, prodRepo repository.Product, studioRepo repository.Studio) *OrderService {
return &OrderService{
repo: repo,
prodRepo: prodRepo,
studioRepo: studioRepo,
}
}
func (o *OrderService) Create(ctx mycontext.Context, req *entity.Order) error {
for i, oi := range req.OrderItem {
if oi.ItemType.IsProduct() {
item, err := o.prodRepo.GetProductByID(ctx, oi.ItemID)
if err != nil {
logger.ContextLogger(ctx).Error("error when get product item", zap.Error(err))
return err
}
req.OrderItem[i].Price = item.Price
req.OrderItem[i].CreatedBy = ctx.RequestedBy()
} else if oi.ItemType.IsStudio() {
//get data studio
item, err := o.studioRepo.GetStudioByID(ctx, oi.ItemID)
if err != nil {
logger.ContextLogger(ctx).Error("error when get studio item", zap.Error(err))
return err
}
req.OrderItem[i].Price = item.Price
req.OrderItem[i].CreatedBy = ctx.RequestedBy()
}
}
orderDB := req.ToOrderDB()
orderDB.CreatedBy = ctx.RequestedBy()
orderDB.Transaction.CreatedBy = ctx.RequestedBy()
//set status
orderDB.Status = order.Paid
orderDB.Transaction.Status = transaction.Paid
orderDB, err := o.repo.CreateOrder(ctx, orderDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create order", zap.Error(err))
return err
}
return nil
}
func (s *OrderService) GetByID(ctx context.Context, id int64) (*entity.Order, error) {
orderDB, err := s.repo.GetOrderByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get order by id", zap.Error(err))
return nil, err
}
return orderDB.ToOrder(), nil
}
func (s *OrderService) GetAll(ctx context.Context, search entity.OrderSearch) ([]*entity.Order, int, error) {
orders, total, err := s.repo.GetAllOrders(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all orders", zap.Error(err))
return nil, 0, err
}
return orders.ToOrderList(), total, nil
}
func (s *OrderService) GetTotalRevenue(ctx context.Context, search entity.OrderTotalRevenueSearch) (float64, int64, error) {
rev, trans, err := s.repo.GetTotalRevenue(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get total revenue orders", zap.Error(err))
return 0, 0, err
}
return rev, trans, nil
}
func (s *OrderService) GetYearlyRevenue(ctx context.Context, year int) (entity.OrderYearlyRevenueList, error) {
result, err := s.repo.GetYearlyRevenue(ctx, year)
if err != nil {
logger.ContextLogger(ctx).Error("error when get yearly revenue orders", zap.Error(err))
return nil, err
}
return result, nil
}
func (s *OrderService) GetBranchRevenue(ctx context.Context, req entity.OrderBranchRevenueSearch) (entity.OrderBranchRevenueList, error) {
result, err := s.repo.GetBranchRevenue(ctx, req)
if err != nil {
logger.ContextLogger(ctx).Error("error when get branch revenue orders", zap.Error(err))
return nil, err
}
return result, nil
}
func (s *OrderService) UpdateStatus(ctx mycontext.Context, id int64, orderReq *entity.Order) (*entity.Order, error) {
existingOrder, err := s.repo.GetOrderByID(ctx, id)
if err != nil {
return nil, err
}
//validate state
if !existingOrder.Status.IsNew() {
return nil, fmt.Errorf("Invalid order status")
}
if existingOrder.Status == orderReq.Status {
return nil, fmt.Errorf("Order status already %s", existingOrder.Status)
}
existingOrder.ToUpdatedOrder(ctx.RequestedBy(), *orderReq)
_, err = s.repo.UpdateOrder(ctx, existingOrder)
if err != nil {
logger.ContextLogger(ctx).Error("error when update user", zap.Error(err))
return nil, err
}
return existingOrder.ToOrder(), nil
}
internal/services/oss/impl.go
+45
View File
@@ -0,0 +1,45 @@
package oss
import (
"context"
"fmt"
"furtuna-be/internal/entity"
"furtuna-be/internal/utils/generator"
"path"
"github.com/go-playground/validator/v10"
)
func (s *OssService) UploadFile(ctx context.Context, req *entity.UploadFileRequest) (*entity.UploadFileResponse, error) {
file := req.FileHeader
req.FileSize = file.Size
req.Ext = path.Ext(file.Filename)
validate := validator.New()
if err := validate.Struct(req); err != nil {
return nil, err
}
// Open the file and read its content
srcFile, err := file.Open()
if err != nil {
return nil, err
}
defer srcFile.Close()
fileContent := make([]byte, file.Size)
_, err = srcFile.Read(fileContent)
if err != nil {
return nil, err
}
filePath := fmt.Sprintf("%v/%v%v", req.FolderName, generator.GenerateFileName(), req.Ext)
fileUrl, err := s.ossRepo.UploadFile(ctx, filePath, fileContent)
if err != nil {
return nil, err
}
return &entity.UploadFileResponse{
FilePath: filePath,
FileUrl: fileUrl,
}, nil
}
internal/services/oss/init.go
+13
View File
@@ -0,0 +1,13 @@
package oss
import "furtuna-be/internal/repository"
type OssService struct {
ossRepo repository.OSSRepository
}
func NewOSSService(ossRepo repository.OSSRepository) *OssService {
return &OssService{
ossRepo: ossRepo,
}
}
internal/services/partner/partner.go
+89
View File
@@ -0,0 +1,89 @@
package partner
import (
"context"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"go.uber.org/zap"
)
type PartnerService struct {
repo repository.PartnerRepository
}
func NewPartnerService(repo repository.PartnerRepository) *PartnerService {
return &PartnerService{
repo: repo,
}
}
func (s *PartnerService) Create(ctx mycontext.Context, PartnerReq *entity.Partner) (*entity.Partner, error) {
PartnerDB := PartnerReq.ToPartnerDB()
PartnerDB.CreatedBy = ctx.RequestedBy()
PartnerDB, err := s.repo.Create(ctx, PartnerDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create Partner", zap.Error(err))
return nil, err
}
return PartnerDB.ToPartner(), nil
}
func (s *PartnerService) Update(ctx mycontext.Context, id int64, PartnerReq *entity.Partner) (*entity.Partner, error) {
existingPartner, err := s.repo.GetByID(ctx, id)
if err != nil {
return nil, err
}
existingPartner.ToUpdatedPartner(ctx.RequestedBy(), *PartnerReq)
updatedPartnerDB, err := s.repo.Update(ctx, existingPartner.ToPartnerDB())
if err != nil {
logger.ContextLogger(ctx).Error("error when update Partner", zap.Error(err))
return nil, err
}
return updatedPartnerDB.ToPartner(), nil
}
func (s *PartnerService) GetByID(ctx context.Context, id int64) (*entity.Partner, error) {
PartnerDB, err := s.repo.GetByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get Partner by id", zap.Error(err))
return nil, err
}
return PartnerDB.ToPartner(), nil
}
func (s *PartnerService) GetAll(ctx context.Context, search entity.PartnerSearch) ([]*entity.Partner, int, error) {
Partneres, total, err := s.repo.GetAll(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all Partneres", zap.Error(err))
return nil, 0, err
}
return Partneres.ToPartnerList(), total, nil
}
func (s *PartnerService) Delete(ctx mycontext.Context, id int64) error {
PartnerDB, err := s.repo.GetByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get Partner by id", zap.Error(err))
return err
}
PartnerDB.SetDeleted(ctx.RequestedBy())
_, err = s.repo.Update(ctx, PartnerDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when update Partner", zap.Error(err))
return err
}
return nil
}
internal/services/product/product.go
+89
View File
@@ -0,0 +1,89 @@
package product
import (
"context"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"go.uber.org/zap"
)
type ProductService struct {
repo repository.Product
}
func NewProductService(repo repository.Product) *ProductService {
return &ProductService{
repo: repo,
}
}
func (s *ProductService) Create(ctx mycontext.Context, productReq *entity.Product) (*entity.Product, error) {
productDB := productReq.ToProductDB()
productDB.CreatedBy = ctx.RequestedBy()
productDB, err := s.repo.CreateProduct(ctx, productDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create product", zap.Error(err))
return nil, err
}
return productDB.ToProduct(), nil
}
func (s *ProductService) Update(ctx mycontext.Context, id int64, productReq *entity.Product) (*entity.Product, error) {
existingProduct, err := s.repo.GetProductByID(ctx, id)
if err != nil {
return nil, err
}
existingProduct.ToUpdatedProduct(ctx.RequestedBy(), *productReq)
updatedProductDB, err := s.repo.UpdateProduct(ctx, existingProduct.ToProductDB())
if err != nil {
logger.ContextLogger(ctx).Error("error when update product", zap.Error(err))
return nil, err
}
return updatedProductDB.ToProduct(), nil
}
func (s *ProductService) GetByID(ctx context.Context, id int64) (*entity.Product, error) {
productDB, err := s.repo.GetProductByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get product by id", zap.Error(err))
return nil, err
}
return productDB.ToProduct(), nil
}
func (s *ProductService) GetAll(ctx context.Context, search entity.ProductSearch) ([]*entity.Product, int, error) {
products, total, err := s.repo.GetAllProducts(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all products", zap.Error(err))
return nil, 0, err
}
return products.ToProductList(), total, nil
}
func (s *ProductService) Delete(ctx mycontext.Context, id int64) error {
productDB, err := s.repo.GetProductByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get product by id", zap.Error(err))
return err
}
productDB.SetDeleted(ctx.RequestedBy())
_, err = s.repo.UpdateProduct(ctx, productDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when update product", zap.Error(err))
return err
}
return nil
}
internal/services/service.go
+110
View File
@@ -0,0 +1,110 @@
package services
import (
"context"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/services/branch"
"furtuna-be/internal/services/order"
"furtuna-be/internal/services/oss"
"furtuna-be/internal/services/partner"
"furtuna-be/internal/services/product"
"furtuna-be/internal/services/studio"
"furtuna-be/internal/services/users"
"furtuna-be/config"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"furtuna-be/internal/services/auth"
"furtuna-be/internal/services/event"
)
type ServiceManagerImpl struct {
AuthSvc Auth
EventSvc Event
UserSvc User
BranchSvc Branch
StudioSvc Studio
ProductSvc Product
OrderSvc Order
OSSSvc OSSService
PartnerSvc Partner
}
func NewServiceManagerImpl(cfg *config.Config, repo *repository.RepoManagerImpl) *ServiceManagerImpl {
return &ServiceManagerImpl{
AuthSvc: auth.New(repo.Auth, repo.Crypto),
EventSvc: event.NewEventService(repo.Event),
UserSvc: users.NewUserService(repo.User, repo.Branch),
BranchSvc: branch.NewBranchService(repo.Branch),
StudioSvc: studio.NewStudioService(repo.Studio),
ProductSvc: product.NewProductService(repo.Product),
OrderSvc: order.NewOrderService(repo.Order, repo.Product, repo.Studio),
OSSSvc: oss.NewOSSService(repo.OSS),
PartnerSvc: partner.NewPartnerService(repo.Partner),
}
}
type Auth interface {
AuthenticateUser(ctx context.Context, email, password string) (*entity.AuthenticateUser, error)
}
type Event interface {
Create(ctx context.Context, eventReq *entity.Event) (*entity.Event, error)
Update(ctx context.Context, id int64, eventReq *entity.Event) (*entity.Event, error)
GetByID(ctx context.Context, id int64) (*entity.Event, error)
GetAll(ctx context.Context, search entity.EventSearch) ([]*entity.Event, int, error)
Delete(ctx context.Context, id int64) error
}
type User interface {
Create(ctx mycontext.Context, userReq *entity.User) (*entity.User, error)
GetAll(ctx mycontext.Context, search entity.UserSearch) ([]*entity.User, int, error)
Update(ctx mycontext.Context, id int64, userReq *entity.User) (*entity.User, error)
GetByID(ctx mycontext.Context, id int64) (*entity.User, error)
Delete(ctx mycontext.Context, id int64) error
}
type Branch interface {
Create(ctx mycontext.Context, branchReq *entity.Branch) (*entity.Branch, error)
Update(ctx mycontext.Context, id int64, branchReq *entity.Branch) (*entity.Branch, error)
GetByID(ctx context.Context, id int64) (*entity.Branch, error)
GetAll(ctx context.Context, search entity.BranchSearch) ([]*entity.Branch, int, error)
Delete(ctx mycontext.Context, id int64) error
}
type Studio interface {
Create(ctx mycontext.Context, studioReq *entity.Studio) (*entity.Studio, error)
Update(ctx mycontext.Context, id int64, studioReq *entity.Studio) (*entity.Studio, error)
GetByID(ctx context.Context, id int64) (*entity.Studio, error)
Search(ctx context.Context, search entity.StudioSearch) ([]*entity.Studio, int, error)
}
type Product interface {
Create(ctx mycontext.Context, productReq *entity.Product) (*entity.Product, error)
Update(ctx mycontext.Context, id int64, productReq *entity.Product) (*entity.Product, error)
GetByID(ctx context.Context, id int64) (*entity.Product, error)
GetAll(ctx context.Context, search entity.ProductSearch) ([]*entity.Product, int, error)
Delete(ctx mycontext.Context, id int64) error
}
type Order interface {
Create(ctx mycontext.Context, req *entity.Order) error
UpdateStatus(ctx mycontext.Context, id int64, orderReq *entity.Order) (*entity.Order, error)
GetByID(ctx context.Context, id int64) (*entity.Order, error)
GetAll(ctx context.Context, search entity.OrderSearch) ([]*entity.Order, int, error)
GetTotalRevenue(ctx context.Context, search entity.OrderTotalRevenueSearch) (float64, int64, error)
GetYearlyRevenue(ctx context.Context, year int) (entity.OrderYearlyRevenueList, error)
GetBranchRevenue(ctx context.Context, req entity.OrderBranchRevenueSearch) (entity.OrderBranchRevenueList, error)
}
type OSSService interface {
UploadFile(ctx context.Context, req *entity.UploadFileRequest) (*entity.UploadFileResponse, error)
}
type Partner interface {
Create(ctx mycontext.Context, branchReq *entity.Partner) (*entity.Partner, error)
Update(ctx mycontext.Context, id int64, branchReq *entity.Partner) (*entity.Partner, error)
GetByID(ctx context.Context, id int64) (*entity.Partner, error)
GetAll(ctx context.Context, search entity.PartnerSearch) ([]*entity.Partner, int, error)
Delete(ctx mycontext.Context, id int64) error
}
internal/services/studio/studio.go
+70
View File
@@ -0,0 +1,70 @@
package studio
import (
"context"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/common/mycontext"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
"go.uber.org/zap"
)
type StudioService struct {
repo repository.Studio
}
func NewStudioService(repo repository.Studio) *StudioService {
return &StudioService{
repo: repo,
}
}
func (s *StudioService) Create(ctx mycontext.Context, studioReq *entity.Studio) (*entity.Studio, error) {
newStudioDB := studioReq.NewStudiosDB()
newStudioDB.CreatedBy = ctx.RequestedBy()
newStudioDB, err := s.repo.CreateStudio(ctx, newStudioDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when creating studio", zap.Error(err))
return nil, err
}
return newStudioDB.ToStudio(), nil
}
func (s *StudioService) Update(ctx mycontext.Context, id int64, studioReq *entity.Studio) (*entity.Studio, error) {
existingStudio, err := s.repo.GetStudioByID(ctx, id)
if err != nil {
return nil, err
}
existingStudio.ToUpdatedStudio(ctx.RequestedBy(), *studioReq)
updatedStudioDB, err := s.repo.UpdateStudio(ctx, existingStudio.ToStudioDB())
if err != nil {
logger.ContextLogger(ctx).Error("error when updating studio", zap.Error(err))
return nil, err
}
return updatedStudioDB.ToStudio(), nil
}
func (s *StudioService) GetByID(ctx context.Context, id int64) (*entity.Studio, error) {
studioDB, err := s.repo.GetStudioByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when getting studio by id", zap.Error(err))
return nil, err
}
return studioDB.ToStudio(), nil
}
func (s *StudioService) Search(ctx context.Context, search entity.StudioSearch) ([]*entity.Studio, int, error) {
studios, total, err := s.repo.SearchStudios(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when getting all studios", zap.Error(err))
return nil, 0, err
}
return studios.ToStudioList(), total, nil
}
internal/services/users/users.go
+118
View File
@@ -0,0 +1,118 @@
package users
import (
"fmt"
"furtuna-be/internal/common/mycontext"
"go.uber.org/zap"
"furtuna-be/internal/common/logger"
"furtuna-be/internal/entity"
"furtuna-be/internal/repository"
)
type UserService struct {
repo repository.User
branchRepo repository.Branch
}
func NewUserService(repo repository.User, branchRepo repository.Branch) *UserService {
return &UserService{
repo: repo,
branchRepo: branchRepo,
}
}
func (s *UserService) Create(ctx mycontext.Context, userReq *entity.User) (*entity.User, error) {
//check
userExist, err := s.repo.GetUserByEmail(ctx, userReq.Email)
if err != nil {
return nil, err
}
if userExist != nil {
return nil, fmt.Errorf("Email already exist")
}
userDB, err := userReq.ToUserDB(ctx.RequestedBy())
if err != nil {
return nil, err
}
userDB, err = s.repo.Create(ctx, userDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when create user", zap.Error(err))
return nil, err
}
return userDB.ToUser(), nil
}
func (s *UserService) GetAll(ctx mycontext.Context, search entity.UserSearch) ([]*entity.User, int, error) {
users, total, err := s.repo.GetAllUsers(ctx, search)
if err != nil {
logger.ContextLogger(ctx).Error("error when get all users", zap.Error(err))
return nil, 0, err
}
return users.ToUserList(), total, nil
}
func (s *UserService) GetByID(ctx mycontext.Context, id int64) (*entity.User, error) {
userDB, err := s.repo.GetUserByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get user by id", zap.Error(err))
return nil, err
}
return userDB.ToUser(), nil
}
func (s *UserService) Update(ctx mycontext.Context, id int64, userReq *entity.User) (*entity.User, error) {
existingUser, err := s.repo.GetUserByID(ctx, id)
if err != nil {
return nil, err
}
//if changed branch
if *userReq.PartnerID > 0 {
branch, err := s.branchRepo.GetBranchByID(ctx, *userReq.PartnerID)
if err != nil {
return nil, err
}
existingUser.BranchName = branch.Name
}
err = existingUser.ToUpdatedUser(*userReq)
if err != nil {
return nil, err
}
updatedUserDB, err := s.repo.UpdateUser(ctx, existingUser)
if err != nil {
logger.ContextLogger(ctx).Error("error when update user", zap.Error(err))
return nil, err
}
return updatedUserDB.ToUser(), nil
}
func (s *UserService) Delete(ctx mycontext.Context, id int64) error {
userDB, err := s.repo.GetUserByID(ctx, id)
if err != nil {
logger.ContextLogger(ctx).Error("error when get user by id", zap.Error(err))
return err
}
userDB.SetDeleted(ctx.RequestedBy())
_, err = s.repo.UpdateUser(ctx, userDB)
if err != nil {
logger.ContextLogger(ctx).Error("error when update user", zap.Error(err))
return err
}
return nil
}