/
beer_service.go
184 lines (167 loc) · 5.4 KB
/
beer_service.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
package adapters
import (
"context"
"errors"
"strings"
"github.com/bvwells/grpc-gateway-example/pkg/domain"
"github.com/bvwells/grpc-gateway-example/proto/beers"
"github.com/golang/protobuf/ptypes/empty"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// BeerInteractor defines a set of APIs for interacting with beers.
type BeerInteractor interface {
// CreateBeer creates a beers.
CreateBeer(ctx context.Context, params *domain.CreateBeerParams) (*domain.Beer, error)
// GetBeer gets a beers.
GetBeer(ctx context.Context, params *domain.GetBeerParams) (*domain.Beer, error)
// UpdateBeer uodates a beers.
UpdateBeer(ctx context.Context, params *domain.UpdateBeerParams) (*domain.Beer, error)
// DeleteBeer deletes a beers.
DeleteBeer(ctx context.Context, params *domain.DeleteBeerParams) error
// ListBeers lists beers.
ListBeers(ctx context.Context, params *domain.ListBeersParams) ([]*domain.Beer, error)
}
// NewBeerService creates a new beer service.
func NewBeerService(interactor BeerInteractor) *BeerService {
return &BeerService{interactor: interactor}
}
// BeerService implements the BeerService service gRPC API.
type BeerService struct {
interactor BeerInteractor
}
// CreateBeer create a beer with specified beer parameters.
func (svc *BeerService) CreateBeer(ctx context.Context, params *beers.CreateBeerRequest) (*beers.Beer, error) {
item, err := svc.interactor.CreateBeer(ctx, &domain.CreateBeerParams{
Name: params.Name,
Type: fromProtoType(params.Type),
Brewer: params.Brewer,
Country: params.Country,
})
if err != nil {
return nil, toError(err)
}
return toProtoBeer(item), nil
}
// GetBeer gets the beer with specified beer identifier.
func (svc *BeerService) GetBeer(ctx context.Context, params *beers.GetBeerRequest) (*beers.Beer, error) {
item, err := svc.interactor.GetBeer(ctx, &domain.GetBeerParams{ID: params.Id})
if err != nil {
return nil, toError(err)
}
return toProtoBeer(item), nil
}
// UpdateBeer updates the beer with specified beer identifier.
func (svc *BeerService) UpdateBeer(ctx context.Context, params *beers.UpdateBeerRequest) (*beers.Beer, error) {
if params.UpdateMask == nil {
return nil, status.Error(codes.InvalidArgument, "no fields specified")
}
updateParams := &domain.UpdateBeerParams{
ID: params.Beer.Id,
}
for _, path := range params.UpdateMask.Paths {
switch field := strings.ToLower(path); field {
case "name":
updateParams.Name = ¶ms.Beer.Name
case "type":
beerType := fromProtoType(params.Beer.Type)
updateParams.Type = &beerType
case "brewer":
updateParams.Brewer = ¶ms.Beer.Brewer
case "country":
updateParams.Country = ¶ms.Beer.Country
default:
return nil, status.Errorf(codes.InvalidArgument, "invalid beer field: %s", field)
}
}
item, err := svc.interactor.UpdateBeer(ctx, updateParams)
if err != nil {
return nil, toError(err)
}
return toProtoBeer(item), nil
}
// DeleteBeer deletes the beer with specified beer identifier.
func (svc *BeerService) DeleteBeer(ctx context.Context, params *beers.DeleteBeerRequest) (*empty.Empty, error) {
err := svc.interactor.DeleteBeer(ctx, &domain.DeleteBeerParams{ID: params.Id})
if err != nil {
return nil, toError(err)
}
return &empty.Empty{}, nil
}
// ListBeers lists all beers.
func (svc *BeerService) ListBeers(ctx context.Context, params *beers.ListBeersRequest) (*beers.ListBeersResponse, error) {
items, err := svc.interactor.ListBeers(ctx, &domain.ListBeersParams{
Page: int(params.Page),
})
if err != nil {
return nil, toError(err)
}
b := &beers.ListBeersResponse{
Beers: make([]*beers.Beer, 0, len(items)),
}
for _, item := range items {
b.Beers = append(b.Beers, toProtoBeer(item))
}
return b, nil
}
func toProtoBeer(in *domain.Beer) *beers.Beer {
return &beers.Beer{
Id: in.ID,
Name: in.Name,
Type: toProtoType(in.Type),
Brewer: in.Brewer,
Country: in.Country,
}
}
func toProtoType(in domain.BeerType) beers.BeerType {
switch in {
case domain.Ale:
return beers.BeerType_BEER_TYPE_ALE
case domain.Bitter:
return beers.BeerType_BEER_TYPE_BITTER
case domain.Lager:
return beers.BeerType_BEER_TYPE_LAGER
case domain.IndiaPaleAle:
return beers.BeerType_BEER_TYPE_INDIA_PALE_ALE
case domain.Stout:
return beers.BeerType_BEER_TYPE_STOUT
case domain.Pilsner:
return beers.BeerType_BEER_TYPE_PILSNER
case domain.Porter:
return beers.BeerType_BEER_TYPE_PORTER
case domain.PaleAle:
return beers.BeerType_BEER_TYPE_PALE_ALE
case domain.Unspecified:
return beers.BeerType_BEER_TYPE_UNSPECIFIED
}
return beers.BeerType_BEER_TYPE_UNSPECIFIED
}
func fromProtoType(in beers.BeerType) domain.BeerType {
switch in {
case beers.BeerType_BEER_TYPE_ALE:
return domain.Ale
case beers.BeerType_BEER_TYPE_BITTER:
return domain.Bitter
case beers.BeerType_BEER_TYPE_LAGER:
return domain.Lager
case beers.BeerType_BEER_TYPE_INDIA_PALE_ALE:
return domain.IndiaPaleAle
case beers.BeerType_BEER_TYPE_STOUT:
return domain.Stout
case beers.BeerType_BEER_TYPE_PILSNER:
return domain.Pilsner
case beers.BeerType_BEER_TYPE_PORTER:
return domain.Porter
case beers.BeerType_BEER_TYPE_PALE_ALE:
return domain.PaleAle
case beers.BeerType_BEER_TYPE_UNSPECIFIED:
return domain.Unspecified
}
return domain.Unspecified
}
func toError(err error) error {
if errors.As(err, &domain.ValidationError{}) {
return status.Error(codes.InvalidArgument, err.Error())
}
return status.Error(codes.Internal, err.Error())
}