19743981475

Committed 27 Nov 2025 05:26PM UTC coverage: 72.203% (-0.007%) from 72.21%

Build # 19743981475

Build Type

push

github

Committed by

et-nik

Commit Message

fix tests

Run Details

9 of 11 new or added lines in 2 files covered. (81.82%)

33 existing lines in 3 files now uncovered.

24962 of 34572 relevant lines covered (72.2%)

380.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.5

/internal/api/daemonapi/serverstasks/updateservertask/handler.go

package updateservertask

import (
        "context"
        "encoding/json"
        "math"
        "net/http"
        "time"

        "github.com/gameap/gameap/internal/api/base"
        "github.com/gameap/gameap/internal/domain"
        "github.com/gameap/gameap/internal/filters"
        "github.com/gameap/gameap/internal/repositories"
        "github.com/gameap/gameap/pkg/api"
        "github.com/gameap/gameap/pkg/auth"
        "github.com/pkg/errors"
)

type Handler struct {
        serverTaskRepo repositories.ServerTaskRepository
        serverRepo     repositories.ServerRepository
        responder      base.Responder
}

func NewHandler(
        serverTaskRepo repositories.ServerTaskRepository,
        serverRepo repositories.ServerRepository,
        responder base.Responder,
) *Handler {
        return &Handler{
                serverTaskRepo: serverTaskRepo,
                serverRepo:     serverRepo,
                responder:      responder,
        }
}

func (h *Handler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
        ctx := r.Context()

        daemonSession := auth.DaemonSessionFromContext(ctx)
        if daemonSession == nil || daemonSession.Node == nil {
                h.responder.WriteError(ctx, rw, api.WrapHTTPError(
                        errors.New("daemon session not found"),
                        http.StatusUnauthorized,
                ))

                return
        }

        taskID, err := api.NewInputReader(r).ReadUint("server_task")
        if err != nil {
                h.responder.WriteError(ctx, rw, api.WrapHTTPError(
                        errors.WithMessage(err, "invalid task ID"),
                        http.StatusBadRequest,
                ))

                return
        }

        input, err := h.parseAndValidateInput(r)
        if err != nil {
                h.responder.WriteError(ctx, rw, err)

                return
        }

        task, err := h.findServerTask(ctx, taskID, daemonSession.Node.ID)
        if err != nil {
                h.responder.WriteError(ctx, rw, err)

                return
        }

        h.updateTask(task, input)

        err = h.serverTaskRepo.Save(ctx, task)
        if err != nil {
                h.responder.WriteError(ctx, rw, api.WrapHTTPError(
                        errors.WithMessage(err, "failed to update server task"),
                        http.StatusInternalServerError,
                ))

                return
        }

        h.responder.Write(ctx, rw, newUpdateServerTaskResponse())
}

func (h *Handler) parseAndValidateInput(r *http.Request) (*updateServerTaskInput, error) {
        input := &updateServerTaskInput{}

        err := json.NewDecoder(r.Body).Decode(&input)
        if err != nil {
                return nil, api.WrapHTTPError(
                        errors.WithMessage(err, "invalid request"),
                        http.StatusBadRequest,
                )
        }

        err = input.Validate()
        if err != nil {
                return nil, api.WrapHTTPError(
                        errors.WithMessage(err, "invalid input"),
                        http.StatusBadRequest,
                )
        }

        return input, nil
}

func (h *Handler) findServerTask(ctx context.Context, taskID, nodeID uint) (*domain.ServerTask, error) {
        tasks, err := h.serverTaskRepo.Find(
                ctx,
                &filters.FindServerTask{
                        IDs:     []uint{taskID},
                        NodeIDs: []uint{nodeID},
                },
                nil,
                nil,
        )
        if err != nil {
                return nil, api.WrapHTTPError(
                        errors.WithMessage(err, "failed to find server task"),
                        http.StatusInternalServerError,
                )
        }

        if len(tasks) == 0 {
                return nil, api.WrapHTTPError(
                        errors.New("server task not found"),
                        http.StatusNotFound,
                )
        }

        return &tasks[0], nil
}

func (h *Handler) updateTask(task *domain.ServerTask, input *updateServerTaskInput) {
        if input.Counter != nil {
                task.Counter = *input.Counter
        } else {
                task.Counter++
        }

        if input.Repeat != nil {
                if *input.Repeat > math.MaxUint8 {
                        *input.Repeat = math.MaxUint8
                }

                task.Repeat = uint8(*input.Repeat) //nolint:gosec // input.Repeat is already validated
        }

        if input.RepeatPeriod != nil {
                task.RepeatPeriod = time.Duration(*input.RepeatPeriod) * time.Second
        }
        if input.ExecuteDate != nil {
                task.ExecuteDate = input.ExecuteDate.Time
        }

        now := time.Now()
        task.UpdatedAt = &now
}

1	package updateservertask
2
3	import (
4	"context"
5	"encoding/json"
6	"math"
7	"net/http"
8	"time"
9
10	"github.com/gameap/gameap/internal/api/base"
11	"github.com/gameap/gameap/internal/domain"
12	"github.com/gameap/gameap/internal/filters"
13	"github.com/gameap/gameap/internal/repositories"
14	"github.com/gameap/gameap/pkg/api"
15	"github.com/gameap/gameap/pkg/auth"
16	"github.com/pkg/errors"
17	)
18
19	type Handler struct {
20	serverTaskRepo repositories.ServerTaskRepository
21	serverRepo repositories.ServerRepository
22	responder base.Responder
23	}
24
25	func NewHandler(
26	serverTaskRepo repositories.ServerTaskRepository,
27	serverRepo repositories.ServerRepository,
28	responder base.Responder,
29	) *Handler {	18✔
30	return &Handler{	18✔
31	serverTaskRepo: serverTaskRepo,	18✔
32	serverRepo: serverRepo,	18✔
33	responder: responder,	18✔
34	}	18✔
35	}	18✔
36
37	func (h Handler) ServeHTTP(rw http.ResponseWriter, r http.Request) {	17✔
38	ctx := r.Context()	17✔
39		17✔
40	daemonSession := auth.DaemonSessionFromContext(ctx)	17✔
41	if daemonSession == nil \|\| daemonSession.Node == nil {	19✔
42	h.responder.WriteError(ctx, rw, api.WrapHTTPError(	2✔
43	errors.New("daemon session not found"),	2✔
44	http.StatusUnauthorized,	2✔
45	))	2✔
46		2✔
47	return	2✔
48	}	2✔
49
50	taskID, err := api.NewInputReader(r).ReadUint("server_task")	15✔
51	if err != nil {	16✔
52	h.responder.WriteError(ctx, rw, api.WrapHTTPError(	1✔
53	errors.WithMessage(err, "invalid task ID"),	1✔
54	http.StatusBadRequest,	1✔
55	))	1✔
56		1✔
57	return	1✔
58	}	1✔
59
60	input, err := h.parseAndValidateInput(r)	14✔
61	if err != nil {	19✔
62	h.responder.WriteError(ctx, rw, err)	5✔
63		5✔
64	return	5✔
65	}	5✔
66
67	task, err := h.findServerTask(ctx, taskID, daemonSession.Node.ID)	9✔
68	if err != nil {	11✔
69	h.responder.WriteError(ctx, rw, err)	2✔
70		2✔
71	return	2✔
72	}	2✔
73
74	h.updateTask(task, input)	7✔
75		7✔
76	err = h.serverTaskRepo.Save(ctx, task)	7✔
77	if err != nil {	7✔
78	h.responder.WriteError(ctx, rw, api.WrapHTTPError(	×
79	errors.WithMessage(err, "failed to update server task"),	×
80	http.StatusInternalServerError,	×
81	))	×
82		×
83	return	×
84	}	×
85
86	h.responder.Write(ctx, rw, newUpdateServerTaskResponse())	7✔
87	}
88
89	func (h Handler) parseAndValidateInput(r http.Request) (*updateServerTaskInput, error) {	14✔
90	input := &updateServerTaskInput{}	14✔
91		14✔
92	err := json.NewDecoder(r.Body).Decode(&input)	14✔
93	if err != nil {	15✔
94	return nil, api.WrapHTTPError(	1✔
95	errors.WithMessage(err, "invalid request"),	1✔
96	http.StatusBadRequest,	1✔
97	)	1✔
98	}	1✔
99
100	err = input.Validate()	13✔
101	if err != nil {	17✔
102	return nil, api.WrapHTTPError(	4✔
103	errors.WithMessage(err, "invalid input"),	4✔
104	http.StatusBadRequest,	4✔
105	)	4✔
106	}	4✔
107
108	return input, nil	9✔
109	}
110
111	func (h Handler) findServerTask(ctx context.Context, taskID, nodeID uint) (domain.ServerTask, error) {	9✔
112	tasks, err := h.serverTaskRepo.Find(	9✔
113	ctx,	9✔
114	&filters.FindServerTask{	9✔
115	IDs: []uint{taskID},	9✔
116	NodeIDs: []uint{nodeID},	9✔
117	},	9✔
118	nil,	9✔
119	nil,	9✔
120	)	9✔
121	if err != nil {	9✔
122	return nil, api.WrapHTTPError(	×
123	errors.WithMessage(err, "failed to find server task"),	×
124	http.StatusInternalServerError,	×
125	)	×
126	}	×
127
128	if len(tasks) == 0 {	11✔
129	return nil, api.WrapHTTPError(	2✔
130	errors.New("server task not found"),	2✔
131	http.StatusNotFound,	2✔
132	)	2✔
133	}	2✔
134
135	return &tasks[0], nil	7✔
136	}
137
138	func (h Handler) updateTask(task domain.ServerTask, input *updateServerTaskInput) {	7✔
139	if input.Counter != nil {	9✔
140	task.Counter = *input.Counter	2✔
141	} else {	7✔
142	task.Counter++	5✔
143	}	5✔
144
145	if input.Repeat != nil {	11✔
146	if *input.Repeat > math.MaxUint8 {	4✔
NEW 147	*input.Repeat = math.MaxUint8	×
NEW 148	}	×
149
150	task.Repeat = uint8(*input.Repeat) //nolint:gosec // input.Repeat is already validated	4✔
151	}
152
153	if input.RepeatPeriod != nil {	11✔
154	task.RepeatPeriod = time.Duration(input.RepeatPeriod) time.Second	4✔
155	}	4✔
156	if input.ExecuteDate != nil {	14✔
157	task.ExecuteDate = input.ExecuteDate.Time	7✔
158	}	7✔
159
160	now := time.Now()	7✔
161	task.UpdatedAt = &now	7✔
162	}

gameap / gameap / 19743981475

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous