sportx/msg.go at main · lakerszhy/sportx · GitHub

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
package main

const (
	statusInitial status = iota
	statusLoading
	statusSuccess
	statusFailed
)

type status int

func (s status) isInitial() bool {
	return s == statusInitial
}

func (s status) isLoading() bool {
	return s == statusLoading
}

func (s status) isSuccess() bool {
	return s == statusSuccess
}

func (s status) isFailed() bool {
	return s == statusFailed
}

type categoriesMsg struct {
	categories []category
	err        error
	status
}

func newCategoriesLoadingMsg() categoriesMsg {
	return categoriesMsg{
		status: statusLoading,
	}
}

func newCategoriesLoadedMsg(categories []category) categoriesMsg {
	return categoriesMsg{
		categories: categories,
		status:     statusSuccess,
	}
}

func newCategoriesFailedMsg(err error) categoriesMsg {
	return categoriesMsg{
		err:    err,
		status: statusFailed,
	}
}

type categorySelectionMsg category

type scheduleMsg struct {
	category category
	matches  []match
	err      error
	status
}

func newScheduleInitialMsg() scheduleMsg {
	return scheduleMsg{
		status: statusInitial,
	}
}

func newScheduleLoadingMsg(category category) scheduleMsg {
	return scheduleMsg{
		category: category,
		status:   statusLoading,
	}
}

func newScheduleLoadedMsg(category category, matches []match) scheduleMsg {
	return scheduleMsg{
		category: category,
		matches:  matches,
		status:   statusSuccess,
	}
}

func newScheduleFailedMsg(category category, err error) scheduleMsg {
	return scheduleMsg{
		category: category,
		err:      err,
		status:   statusFailed,
	}
}

type matchSelectionMsg string

type textLivesMsg struct {
	matchID   string
	textLives []textLive
	hasData   bool
	err       error
	status
}

func newTextLivesInitialMsg() textLivesMsg {
	return textLivesMsg{
		status: statusInitial,
	}
}

func newTextLivesLoadingMsg(matchID string) textLivesMsg {
	return textLivesMsg{
		matchID: matchID,
		status:  statusLoading,
	}
}

func newTextLivesLoadedMsg(matchID string, textLives []textLive) textLivesMsg {
	return textLivesMsg{
		matchID:   matchID,
		textLives: textLives,
		hasData:   true,
		status:    statusSuccess,
	}
}

func newTextLivesNoDataMsg(matchID string) textLivesMsg {
	return textLivesMsg{
		matchID: matchID,
		hasData: false,
		status:  statusSuccess,
	}
}

func newTextLivesFailedMsg(matchID string, err error) textLivesMsg {
	return textLivesMsg{
		matchID: matchID,
		hasData: true,
		err:     err,
		status:  statusFailed,
	}
}

type statsMsg struct {
	matchID string
	stats   *stats
	err     error
	status
}

func newStatsInitialMsg() statsMsg {
	return statsMsg{
		status: statusInitial,
	}
}

func newStatsLoadingMsg(matchID string) statsMsg {
	return statsMsg{
		matchID: matchID,
		status:  statusLoading,
	}
}

func newStatsLoadedMsg(matchID string, s *stats) statsMsg {
	return statsMsg{
		matchID: matchID,
		stats:   s,
		status:  statusSuccess,
	}
}

func newStatsFailedMsg(matchID string, err error) statsMsg {
	return statsMsg{
		matchID: matchID,
		err:     err,
		status:  statusFailed,
	}
}