generated from sumelms/microservice-template
/
list_subscription.go
159 lines (139 loc) · 4.71 KB
/
list_subscription.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
package endpoints
import (
"context"
"fmt"
"net/http"
"time"
"github.com/go-kit/kit/endpoint"
kithttp "github.com/go-kit/kit/transport/http"
"github.com/google/uuid"
"github.com/sumelms/microservice-course/internal/subscription/domain"
)
type ListSubscriptionsRequest struct {
CourseUUID uuid.UUID `json:"course_uuid"`
UserUUID uuid.UUID `json:"user_uuid"`
}
type SubscriptionCourseResponse struct {
UUID uuid.UUID `db:"uuid" json:"uuid"`
Code string `db:"code" json:"code"`
Name string `db:"name" json:"name"`
}
type SubscriptionMatrixResponse struct {
UUID *uuid.UUID `db:"uuid" json:"uuid,omitempty"`
Code *string `db:"code" json:"code,omitempty"`
Name *string `db:"name" json:"name,omitempty"`
}
type SubscriptionsResponse struct {
UUID uuid.UUID `json:"uuid"`
UserUUID uuid.UUID `json:"user_uuid"`
Course *SubscriptionCourseResponse `json:"course,omitempty"`
CourseUUID *uuid.UUID `json:"course_uuid,omitempty"`
Matrix *SubscriptionMatrixResponse `json:"matrix,omitempty"`
MatrixUUID *uuid.UUID `json:"matrix_uuid,omitempty"`
Role string `json:"role"`
ExpiresAt *time.Time `json:"expires_at,omitempty"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
}
type ListSubscriptionsResponse struct {
Subscriptions []SubscriptionsResponse `json:"subscriptions"`
}
// NewListSubscriptionsHandler list subscriptions handler
// @Summary List subscriptions
// @Description List a new subscriptions
// @Tags subscriptions
// @Produce json
// @Param course_uuid query string false "course search by uuid" Format(uuid)
// @Param user_uuid query string false "user search by uuid" Format(uuid)
// @Success 200 {object} ListSubscriptionsResponse
// @Failure 400 {object} error
// @Failure 404 {object} error
// @Failure 500 {object} error
// @Router /subscriptions [get].
func NewListSubscriptionsHandler(s domain.ServiceInterface, opts ...kithttp.ServerOption) *kithttp.Server {
return kithttp.NewServer(
makeListSubscriptionsEndpoint(s),
decodeListSubscriptionsRequest,
encodeListSubscriptionsResponse,
opts...,
)
}
func SerializeCourse(subscription domain.Subscription) *SubscriptionCourseResponse {
if subscription.Course != nil {
return &SubscriptionCourseResponse{
UUID: subscription.Course.UUID,
Code: subscription.Course.Code,
Name: subscription.Course.Name,
}
}
return nil
}
func SerializeMatrix(subscription domain.Subscription) *SubscriptionMatrixResponse {
if subscription.Matrix != nil {
return &SubscriptionMatrixResponse{
UUID: subscription.Matrix.UUID,
Code: subscription.Matrix.Code,
Name: subscription.Matrix.Name,
}
}
return nil
}
func makeListSubscriptionsEndpoint(s domain.ServiceInterface) endpoint.Endpoint {
return func(ctx context.Context, request interface{}) (interface{}, error) {
req, ok := request.(ListSubscriptionsRequest)
if !ok {
return nil, fmt.Errorf("invalid argument")
}
filters := &domain.SubscriptionFilters{}
if req.CourseUUID != uuid.Nil {
filters.CourseUUID = req.CourseUUID
}
if req.UserUUID != uuid.Nil {
filters.UserUUID = req.UserUUID
}
subscriptions, err := s.Subscriptions(ctx, filters)
if err != nil {
return nil, err
}
var list []SubscriptionsResponse
for i := range subscriptions {
sub := subscriptions[i]
list = append(list, SubscriptionsResponse{
UUID: sub.UUID,
UserUUID: sub.UserUUID,
CourseUUID: sub.CourseUUID,
Course: SerializeCourse(sub),
MatrixUUID: sub.MatrixUUID,
Matrix: SerializeMatrix(sub),
Role: sub.Role,
ExpiresAt: sub.ExpiresAt,
CreatedAt: sub.CreatedAt,
UpdatedAt: sub.UpdatedAt,
})
}
return &ListSubscriptionsResponse{Subscriptions: list}, nil
}
}
func decodeListSubscriptionsRequest(_ context.Context, r *http.Request) (interface{}, error) {
courseUUID := r.FormValue("course_uuid")
userUUID := r.FormValue("user_uuid")
request := ListSubscriptionsRequest{}
if len(courseUUID) > 0 {
parsedCourseUUID, err := uuid.Parse(courseUUID)
if err != nil {
return nil, fmt.Errorf("invalid course UUID: %v", err)
}
request.CourseUUID = parsedCourseUUID
}
if len(userUUID) > 0 {
parsedUserUUID, err := uuid.Parse(userUUID)
if err != nil {
return nil, fmt.Errorf("invalid user UUID: %v", err)
}
request.UserUUID = parsedUserUUID
}
return request, nil
}
func encodeListSubscriptionsResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error {
return kithttp.EncodeJSONResponse(ctx, w, response)
}