130 lines
3.4 KiB
Go
130 lines
3.4 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
|
|
"mgit.msbls.de/m/mcables/internal/db"
|
|
)
|
|
|
|
func (h *handlers) solve(w http.ResponseWriter, r *http.Request) {
|
|
pid, ok := parseInt64Path(r, "pid")
|
|
if !ok {
|
|
writeError(w, db.ErrInvalidInput, "pid must be a positive integer")
|
|
return
|
|
}
|
|
preview := r.URL.Query().Get("preview") == "1"
|
|
res, err := h.store.Solve(pid, preview)
|
|
if err != nil {
|
|
writeError(w, err, nil)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, res)
|
|
}
|
|
|
|
// ports-and-resolve combo: POST a new port to a device + re-run solve in
|
|
// the same request. Used by the inspector quick-fix.
|
|
type portsAndResolveBody struct {
|
|
TypeID int64 `json:"type_id"`
|
|
Label string `json:"label,omitempty"`
|
|
XOffset float64 `json:"x_offset,omitempty"`
|
|
YOffset float64 `json:"y_offset,omitempty"`
|
|
}
|
|
|
|
func (h *handlers) portsAndResolve(w http.ResponseWriter, r *http.Request) {
|
|
pid, ok := parseInt64Path(r, "pid")
|
|
if !ok {
|
|
writeError(w, db.ErrInvalidInput, "pid must be a positive integer")
|
|
return
|
|
}
|
|
id, ok := parseInt64Path(r, "id")
|
|
if !ok {
|
|
writeError(w, db.ErrInvalidInput, "id must be a positive integer")
|
|
return
|
|
}
|
|
var body portsAndResolveBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, errors.Join(db.ErrInvalidInput, err), nil)
|
|
return
|
|
}
|
|
res, err := h.store.PortsAndResolve(pid, id, body.TypeID, body.Label, body.XOffset, body.YOffset)
|
|
if err != nil {
|
|
writeError(w, err, nil)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, res)
|
|
}
|
|
|
|
// -------------------------------------------------------- setup templates
|
|
|
|
func (h *handlers) listSetupTemplates(w http.ResponseWriter, _ *http.Request) {
|
|
ts, err := h.store.ListSetupTemplates()
|
|
if err != nil {
|
|
writeError(w, err, nil)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, ts)
|
|
}
|
|
|
|
type applyTemplateBody struct {
|
|
TemplateID int64 `json:"template_id"`
|
|
NameOverrides map[string]string `json:"name_overrides,omitempty"`
|
|
SkipDevices []int64 `json:"skip_devices,omitempty"`
|
|
OriginX float64 `json:"origin_x,omitempty"`
|
|
OriginY float64 `json:"origin_y,omitempty"`
|
|
}
|
|
|
|
func (h *handlers) applyTemplate(w http.ResponseWriter, r *http.Request) {
|
|
pid, ok := parseInt64Path(r, "pid")
|
|
if !ok {
|
|
writeError(w, db.ErrInvalidInput, "pid must be a positive integer")
|
|
return
|
|
}
|
|
var body applyTemplateBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, errors.Join(db.ErrInvalidInput, err), nil)
|
|
return
|
|
}
|
|
opts := db.ApplyTemplateOptions{
|
|
NameOverrides: map[int64]string{},
|
|
SkipDevices: map[int64]bool{},
|
|
OriginX: body.OriginX,
|
|
OriginY: body.OriginY,
|
|
}
|
|
// JSON keys are strings; parse to int64.
|
|
for k, v := range body.NameOverrides {
|
|
var tid int64
|
|
_, _ = fmtSscan(k, &tid)
|
|
if tid > 0 {
|
|
opts.NameOverrides[tid] = v
|
|
}
|
|
}
|
|
for _, tid := range body.SkipDevices {
|
|
opts.SkipDevices[tid] = true
|
|
}
|
|
res, err := h.store.ApplyTemplate(pid, body.TemplateID, opts)
|
|
if err != nil {
|
|
writeError(w, err, nil)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, res)
|
|
}
|
|
|
|
// fmtSscan parses a base-10 int from a string, returning (n, nil) on success.
|
|
// Inline so handlers don't pull in strconv just for one call site.
|
|
func fmtSscan(s string, out *int64) (int, error) {
|
|
var v int64
|
|
read := 0
|
|
for i := 0; i < len(s); i++ {
|
|
c := s[i]
|
|
if c < '0' || c > '9' {
|
|
break
|
|
}
|
|
v = v*10 + int64(c-'0')
|
|
read++
|
|
}
|
|
*out = v
|
|
return read, nil
|
|
}
|