reprogl

1
package backend
2

3
import (
4
	"bytes"
5
	"encoding/json"
6
	"errors"
7
	"fmt"
8
	"io"
9
	"net/http"
10

11
	"xelbot.com/reprogl/services/oauth"
12
)
13

14
type ExternalUserDTO struct {
15
	UserData  *oauth.UserData `json:"userData"`
16
	UserAgent string          `json:"userAgent"`
17
	IP        string          `json:"ipAddress"`
18
}
19

20
type CreatedUserDTO struct {
21
	ID          int    `json:"id"`
22
	Username    string `json:"username"`
23
	Email       string `json:"email"`
24
	Role        string `json:"role"`
25
	DisplayName string `json:"displayName,omitempty"`
26
	ImageHash   string `json:"imageHash"`
27
}
28

29
type ProfileDTO struct {
30
	ID          int
31
	Username    string `json:"username"`
32
	Email       string `json:"email"`
33
	DisplayName string `json:"displayName"`
34
	Role        string `json:"role"`
35
	IsMale      bool   `json:"isMale"`
36
}
37

38
type CreateUserResponse struct {
39
	Violations []FormError     `json:"errors,omitempty"`
40
	User       *CreatedUserDTO `json:"user,omitempty"`
41
}
42

43
func SendUserData(userData ExternalUserDTO) (*CreateUserResponse, error) {
44
	jsonBody, err := json.Marshal(userData)
45
	if err != nil {
46
		return nil, err
47
	}
48

49
	request, err := http.NewRequest(http.MethodPost, apiURL()+"/api/users/external", bytes.NewReader(jsonBody))
50
	if err != nil {
51
		return nil, err
52
	}
53

54
	request.Header.Set("Content-Type", "application/json")
55

56
	response, err := send(request)
57
	if err != nil {
58
		return nil, err
59
	}
60

61
	if !(response.StatusCode == http.StatusOK ||
62
		response.StatusCode == http.StatusCreated ||
63
		response.StatusCode == http.StatusUnprocessableEntity) {
64
		return nil, errors.New("backend: unexpected HTTP status " + response.Status)
65
	}
66

67
	defer response.Body.Close()
68
	buf, err := io.ReadAll(response.Body)
69
	if err != nil {
70
		return nil, err
71
	}
72

73
	if !json.Valid(buf) {
74
		return nil, errors.New("invalid JSON string")
75
	}
76

77
	var result CreateUserResponse
78
	err = json.Unmarshal(buf, &result)
79
	if err != nil {
80
		return nil, err
81
	}
82

83
	return &result, nil
84
}
85

86
func SendProfileData(profileData ProfileDTO) (*CreateUserResponse, error) {
87
	var requestData = struct {
88
		User ProfileDTO `json:"user"`
89
	}{
90
		User: profileData,
91
	}
92

93
	jsonBody, err := json.Marshal(requestData)
94
	if err != nil {
95
		return nil, err
96
	}
97

98
	request, err := http.NewRequest(http.MethodPut, apiURL()+fmt.Sprintf("/api/users/%d", profileData.ID), bytes.NewReader(jsonBody))
99
	if err != nil {
100
		return nil, err
101
	}
102

103
	request.Header.Set("Content-Type", "application/json")
104

105
	response, err := send(request)
106
	if err != nil {
107
		return nil, err
108
	}
109

110
	if !(response.StatusCode == http.StatusOK ||
111
		response.StatusCode == http.StatusUnprocessableEntity) {
112
		return nil, errors.New("backend: unexpected HTTP status " + response.Status)
113
	}
114

115
	defer response.Body.Close()
116
	buf, err := io.ReadAll(response.Body)
117
	if err != nil {
118
		return nil, err
119
	}
120

121
	if !json.Valid(buf) {
122
		return nil, errors.New("invalid JSON string")
123
	}
124

125
	var result CreateUserResponse
126
	err = json.Unmarshal(buf, &result)
127
	if err != nil {
128
		return nil, err
129
	}
130

131
	return &result, nil
132
}
133

134
func (u *CreatedUserDTO) Nickname() string {
135
	if len(u.DisplayName) > 0 {
136
		return u.DisplayName
137
	}
138

139
	return u.Username
140
}
141