droboticflow/internal/api/project_members.go
eust-w 6e66e37b0a ✨ Switch account management create/edit to phone (ticket 02)
Admin account-management UI and API now validate/enforce phone instead
of email on create/edit. Production Fanyu data migration deferred to
deployment time per spec decision 7 — not executed here.

Merge conflict resolution + gap fixes found while reconciling 02 and 04:
- src/types.ts / UserContext.tsx / users.ts: kept Email required + Phone
  optional (matches current migration state — login still uses email
  until ticket 03); createUser/updateCurrentUser signatures reconciled
  to the versions that are actually wired to real backend behavior.
- internal/api/project_members.go: projectMemberView never exposed
  Phone (ticket 04's frontend rename to userPhone had nothing to read).
  Renamed UserEmail->UserPhone and populated it from user.Phone.
- internal/store/memory.go + mongo.go: ListProjectMemberUsers's field
  whitelist projection dropped Phone entirely (pre-existed the Phone
  field, never updated) — same root cause as project_members.go, one
  layer down.
- internal/api/auth.go: handleCurrentUserProfileUpdate/
  currentUserProfilePatch still only supported Email; self-service
  profile edit silently no-opped on phone. Wired to phone validation
  mirroring the ticket-02 admin create/edit pattern.
- Updated 3 tests whose expectations depended on the self-profile-update
  gap above (TestSessionAuthTenantIsolationAndRolePermissions,
  TestUserEmailUniquenessValidation, TestProjectMemberDisplayScopedBatch)
  to phone; verified full internal/api suite back to the 75-failure
  baseline (byte-identical failing test names) and frontend suite at
  599/586/13 baseline.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 13:35:30 +08:00

614 lines
24 KiB
Go

package api
import (
"context"
"droboticflow/internal/store"
"errors"
"fmt"
"net/http"
"os"
"sort"
"strings"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
type supplierInput struct {
Name string `json:"name"`
}
type projectMemberInput struct {
UserID string `json:"userId"`
SupplierID string `json:"supplierId,omitempty"`
Roles []domain.AnnotationAssignmentRole `json:"roles"`
}
type projectMemberBulkInput struct {
Action string `json:"action"`
MemberIDs []string `json:"memberIds"`
Roles []domain.AnnotationAssignmentRole `json:"roles,omitempty"`
Entries []projectMemberInput `json:"entries,omitempty"`
}
type projectMemberBulkResult struct {
Created int `json:"created"`
Updated int `json:"updated"`
}
func isOrganizationAdmin(principal *authenticatedPrincipal) bool {
return principal != nil && (principal.User.IsSuperAdmin || principal.User.Role == domain.UserRoleAdmin)
}
func isSupplierManager(principal *authenticatedPrincipal) bool {
return principal != nil && principal.User.Role == domain.UserRoleSupplierManager && strings.TrimSpace(principal.User.SupplierID) != ""
}
func projectMemberManager(principal *authenticatedPrincipal) bool {
return isOrganizationAdmin(principal) || isSupplierManager(principal)
}
func projectMemberSupplierAllowed(principal *authenticatedPrincipal, supplierID string) bool {
if isOrganizationAdmin(principal) {
return true
}
return isSupplierManager(principal) && strings.TrimSpace(principal.User.SupplierID) == strings.TrimSpace(supplierID)
}
func (server *server) projectMemberVisibleTo(principal *authenticatedPrincipal, member domain.ProjectMemberRecord) bool {
if isOrganizationAdmin(principal) {
return true
}
if principal == nil {
return false
}
if principal.User.Role == domain.UserRoleSupplierManager {
return strings.TrimSpace(principal.User.SupplierID) != "" && principal.User.SupplierID == member.SupplierID
}
return principal.User.ID == member.UserID
}
func (server *server) handleSuppliersList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListSuppliers(request.Context(), server.requestOrganizationID(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
visible := items[:0]
for _, item := range items {
if item.Status != "deleted" {
visible = append(visible, item)
}
}
items = visible
principal, _ := currentPrincipal(request)
if principal != nil && principal.User.Role == domain.UserRoleSupplierManager {
filtered := items[:0]
for _, item := range items {
if item.ID == principal.User.SupplierID {
filtered = append(filtered, item)
}
}
items = filtered
}
if request.URL.Query().Get("forProject") == "true" {
items = projectSelectableSuppliers(items, os.Getenv("DROBOTICFLOW_PROJECT_SUPPLIER_IDS"))
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
// This is a creation-picker preference, not an authorization rule. Historical
// supplier lookups and existing task access must continue to work unchanged.
func projectSelectableSuppliers(items []domain.SupplierRecord, configured string) []domain.SupplierRecord {
allowed := map[string]bool{}
for _, id := range strings.Split(configured, ",") {
if id = strings.TrimSpace(id); id != "" {
allowed[id] = true
}
}
result := make([]domain.SupplierRecord, 0, len(items))
for _, item := range items {
if strings.EqualFold(strings.TrimSpace(item.Status), "active") && (len(allowed) == 0 || allowed[item.ID] || item.IsDefault) {
result = append(result, item)
}
}
return result
}
func (server *server) handleSupplierCreate(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !isOrganizationAdmin(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization admin is required"})
return
}
var payload supplierInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.Name = strings.TrimSpace(payload.Name)
if payload.Name == "" {
renderValidationError(writer, validationIssue{Field: "name", Message: "name is required"})
return
}
if _, err := server.store.EnsureDefaultSupplier(request.Context(), server.requestOrganizationID(request)); err != nil {
renderError(writer, 500, err)
return
}
item, err := server.store.MutateSupplier(request.Context(), server.requestOrganizationID(request), "", payload.Name, false)
if err != nil {
renderSupplierMutationError(writer, err)
return
}
renderJSON(writer, http.StatusCreated, item)
}
// Display data belongs to the read response, not the persisted membership.
type projectMemberView struct {
domain.ProjectMemberRecord
UserName string `json:"userName"`
UserPhone string `json:"userPhone"`
UserStatus string `json:"userStatus"`
}
func (server *server) handleProjectMembersList(writer http.ResponseWriter, request *http.Request) {
projectID := strings.TrimSpace(chi.URLParam(request, "id"))
project, err := server.store.GetProject(request.Context(), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil || !server.filterByTenant(request, project.OrganizationID) {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project not found"})
return
}
items, err := server.store.ListProjectMembers(request.Context(), project.OrganizationID, project.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
filtered := items[:0]
for _, item := range items {
if server.projectMemberVisibleTo(principal, item) {
filtered = append(filtered, item)
}
}
sort.Slice(filtered, func(left, right int) bool { return filtered[left].CreatedAt < filtered[right].CreatedAt })
ids := make([]string, 0, len(filtered))
for _, member := range filtered {
ids = append(ids, member.UserID)
}
users, err := server.store.ListProjectMemberUsers(request.Context(), project.OrganizationID, ids)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
directory := make(map[string]domain.UserRecord, len(users))
for _, user := range users {
directory[user.ID] = user
}
result := make([]projectMemberView, 0, len(filtered))
for _, member := range filtered {
view := projectMemberView{ProjectMemberRecord: member, UserStatus: "missing"}
view.Roles = nil
if user, ok := directory[member.UserID]; ok {
view.UserName, view.UserPhone, view.UserStatus = user.Name, user.Phone, string(user.Status)
view.Roles = domain.AccountProductionRoles(user)
if view.UserStatus == "" {
view.UserStatus = "active"
}
}
result = append(result, view)
}
renderJSON(writer, http.StatusOK, map[string]any{"items": result})
}
func (server *server) saveProjectMember(writer http.ResponseWriter, request *http.Request, principal *authenticatedPrincipal, project *domain.ProjectRecord, member *domain.ProjectMemberRecord, payload projectMemberInput, created bool) {
payload.UserID = strings.TrimSpace(payload.UserID)
payload.SupplierID = strings.TrimSpace(payload.SupplierID)
if payload.UserID == "" {
renderValidationError(writer, validationIssue{Field: "member", Message: "userId and at least one project role are required"})
return
}
user, err := server.store.GetUser(request.Context(), payload.UserID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if user == nil || !annotationOrganizationEqual(user.OrganizationID, project.OrganizationID) {
renderValidationError(writer, validationIssue{Field: "userId", Message: "user must exist in the current organization"})
return
}
roles := domain.AccountProductionRoles(*user)
if len(roles) != 1 || (len(payload.Roles) > 0 && (len(payload.Roles) != 1 || payload.Roles[0] != roles[0])) {
renderValidationError(writer, validationIssue{Field: "roles", Message: "项目角色必须与账号唯一角色一致,请在账号管理中修改"})
return
}
if !projectMemberSupplierAllowed(principal, user.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"code": "supplier_scope_forbidden", "error": "只能维护本供应商的项目成员"})
return
}
supplierID, scopeErr := server.inheritedEmployeeSupplier(request.Context(), principal, project.OrganizationID, *user, payload.SupplierID)
if scopeErr != nil {
renderValidationError(writer, validationIssue{Field: "supplierId", Message: scopeErr.Error()})
return
}
if member != nil && member.SupplierID != supplierID {
renderJSON(writer, http.StatusConflict, map[string]string{"code": "supplier_immutable", "error": "项目成员归属与账号不一致,请按确认的历史数据清单处理"})
return
}
payload.SupplierID = supplierID
if member == nil {
member = &domain.ProjectMemberRecord{ID: domain.NewID("project-member"), OrganizationID: project.OrganizationID, ProjectID: project.ID, UserID: user.ID, CreatedAt: nowISO()}
}
member.SupplierID = payload.SupplierID
member.Roles = roles
if err := server.store.UpsertProjectMember(request.Context(), *member); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if created {
renderJSON(writer, http.StatusCreated, member)
return
}
renderJSON(writer, http.StatusOK, member)
}
func (server *server) handleProjectMemberCreate(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !projectMemberManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization admin or supplier manager is required"})
return
}
projectID := strings.TrimSpace(chi.URLParam(request, "id"))
project, err := server.store.GetProject(request.Context(), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil || !server.filterByTenant(request, project.OrganizationID) {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project not found"})
return
}
var payload projectMemberInput
if !decodeJSON(writer, request, &payload) {
return
}
existing, err := server.store.GetProjectMemberByProjectUser(request.Context(), project.OrganizationID, project.ID, strings.TrimSpace(payload.UserID))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if existing != nil {
renderJSON(writer, http.StatusConflict, map[string]any{"error": "project member already exists", "member": existing})
return
}
server.saveProjectMember(writer, request, principal, project, nil, payload, true)
}
func (server *server) handleProjectMemberUpdate(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !projectMemberManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization admin or supplier manager is required"})
return
}
member, err := server.store.GetProjectMember(request.Context(), strings.TrimSpace(chi.URLParam(request, "memberId")))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if member == nil || !server.filterByTenant(request, member.OrganizationID) || member.ProjectID != strings.TrimSpace(chi.URLParam(request, "id")) {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project member not found"})
return
}
if !projectMemberSupplierAllowed(principal, member.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "supplier manager may only maintain project members in their own supplier", "code": "supplier_scope_forbidden"})
return
}
project, err := server.store.GetProject(request.Context(), member.ProjectID)
if err != nil || project == nil {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project not found"})
}
return
}
var payload projectMemberInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.UserID = member.UserID
server.saveProjectMember(writer, request, principal, project, member, payload, false)
}
func (server *server) releaseProjectMemberTasks(ctx context.Context, organizationID string, member domain.ProjectMemberRecord, actorID string) (int, error) {
items, err := server.store.ListHumanItems(ctx, organizationID, domain.HumanItemQuery{ProjectID: member.ProjectID})
if err != nil {
return 0, err
}
released := 0
for _, item := range items {
if item.AssignedUserID != member.UserID || (member.SupplierID != "" && item.SupplierID != "" && item.SupplierID != member.SupplierID) || !humanItemPending(item.Status) {
continue
}
expectedVersion := item.Version
item.AssignedUserID = ""
item.ClaimedAt = ""
item.Version++
if item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress {
item.Status = domain.HumanItemReady
}
updated, updateErr := server.store.UpdateHumanItemVersioned(ctx, item, expectedVersion)
if updateErr != nil {
return released, updateErr
}
if !updated {
return released, nil
}
_ = server.store.AppendHumanEvent(ctx, domain.HumanEventRecord{OrganizationID: item.OrganizationID, BatchID: item.BatchID, ItemID: item.ID, StageID: item.CurrentStageID, Round: item.ReviewRound, EventType: "project_member_removed_release", ActorUserID: actorID, ItemVersion: item.Version, Payload: map[string]any{"projectMemberId": member.ID}, CreatedAt: nowISO()})
released++
}
return released, nil
}
func (server *server) handleProjectMemberDelete(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !projectMemberManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization admin or supplier manager is required"})
return
}
member, err := server.store.GetProjectMember(request.Context(), strings.TrimSpace(chi.URLParam(request, "memberId")))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if member == nil || member.ProjectID != strings.TrimSpace(chi.URLParam(request, "id")) || !server.filterByTenant(request, member.OrganizationID) {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project member not found"})
return
}
if !projectMemberSupplierAllowed(principal, member.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "supplier manager may only maintain project members in their own supplier", "code": "supplier_scope_forbidden"})
return
}
releaseTasks := !strings.EqualFold(strings.TrimSpace(request.URL.Query().Get("releaseTasks")), "false")
if releaseTasks {
if _, err := server.releaseProjectMemberTasks(request.Context(), member.OrganizationID, *member, principal.User.ID); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
deleted, err := server.store.DeleteProjectMember(request.Context(), member.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !deleted {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project member not found"})
return
}
writer.WriteHeader(http.StatusNoContent)
}
func (server *server) handleProjectMembersBulk(writer http.ResponseWriter, request *http.Request) {
principal, _ := currentPrincipal(request)
if !projectMemberManager(principal) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "organization admin or supplier manager is required"})
return
}
projectID := strings.TrimSpace(chi.URLParam(request, "id"))
project, err := server.store.GetProject(request.Context(), projectID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if project == nil || !server.filterByTenant(request, project.OrganizationID) {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "project not found"})
return
}
var payload projectMemberBulkInput
if !decodeJSON(writer, request, &payload) {
return
}
payload.Action = strings.ToLower(strings.TrimSpace(payload.Action))
if payload.Action == "set_roles" {
renderJSON(writer, 409, map[string]string{"error": "项目不再单独分配角色,请在账号管理中修改"})
return
}
if payload.Action == "add" {
server.handleProjectMembersBulkAdd(writer, request, principal, project, payload.Entries)
return
}
if len(payload.MemberIDs) == 0 || payload.Action != "remove" {
renderValidationError(writer, validationIssue{Field: "bulk", Message: "memberIds and action add or remove are required"})
return
}
members := make([]domain.ProjectMemberRecord, 0, len(payload.MemberIDs))
for _, id := range payload.MemberIDs {
member, err := server.store.GetProjectMember(request.Context(), strings.TrimSpace(id))
if err != nil || member == nil || member.ProjectID != projectID || !server.filterByTenant(request, member.OrganizationID) {
continue
}
if !projectMemberSupplierAllowed(principal, member.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "supplier manager may only maintain project members in their own supplier", "code": "supplier_scope_forbidden"})
return
}
if isSupplierManager(principal) {
user, userErr := server.store.GetUser(request.Context(), member.UserID)
if userErr != nil {
renderError(writer, http.StatusInternalServerError, userErr)
return
}
if user == nil || strings.TrimSpace(user.SupplierID) != strings.TrimSpace(principal.User.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "supplier manager may only maintain users and project members in their own supplier", "code": "supplier_scope_forbidden"})
return
}
}
members = append(members, *member)
}
updated := 0
for index := range members {
member := &members[index]
var err error
if _, err = server.releaseProjectMemberTasks(request.Context(), member.OrganizationID, *member, principal.User.ID); err == nil {
_, err = server.store.DeleteProjectMember(request.Context(), member.ID)
}
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
updated++
}
renderJSON(writer, http.StatusOK, projectMemberBulkResult{Updated: updated})
}
func (server *server) handleProjectMembersBulkAdd(writer http.ResponseWriter, request *http.Request, principal *authenticatedPrincipal, project *domain.ProjectRecord, entries []projectMemberInput) {
if len(entries) == 0 {
renderValidationError(writer, validationIssue{Field: "entries", Message: "at least one project member entry is required"})
return
}
// Validate the entire request before writing any member. This makes invalid
// users, suppliers, roles, and duplicates a whole-request failure instead of
// leaving a partially created project membership set.
prepared := make([]domain.ProjectMemberRecord, 0, len(entries))
seenUsers := make(map[string]int, len(entries))
for index, entry := range entries {
entry.UserID = strings.TrimSpace(entry.UserID)
entry.SupplierID = strings.TrimSpace(entry.SupplierID)
if entry.UserID == "" {
renderValidationError(writer, validationIssue{Field: "entries", Message: "every entry requires userId and at least one project role"})
return
}
if firstIndex, exists := seenUsers[entry.UserID]; exists {
renderJSON(writer, http.StatusConflict, map[string]any{
"error": "duplicate user in bulk project member request",
"code": "duplicate_project_member_entry",
"userId": entry.UserID,
"firstIndex": firstIndex,
"index": index,
})
return
}
seenUsers[entry.UserID] = index
existing, err := server.store.GetProjectMemberByProjectUser(request.Context(), project.OrganizationID, project.ID, entry.UserID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if existing != nil {
renderJSON(writer, http.StatusConflict, map[string]any{
"error": "project member already exists",
"code": "project_member_exists",
"userId": entry.UserID,
"member": existing,
})
return
}
user, err := server.store.GetUser(request.Context(), entry.UserID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if user == nil || !annotationOrganizationEqual(user.OrganizationID, project.OrganizationID) {
renderValidationError(writer, validationIssue{Field: "entries", Message: "every user must exist in the current organization"})
return
}
roles := domain.AccountProductionRoles(*user)
if len(roles) != 1 || (len(entry.Roles) > 0 && (len(entry.Roles) != 1 || entry.Roles[0] != roles[0])) {
renderValidationError(writer, validationIssue{Field: "roles", Message: "项目角色必须与账号唯一角色一致"})
return
}
if !projectMemberSupplierAllowed(principal, user.SupplierID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"code": "supplier_scope_forbidden", "error": "只能维护本供应商的项目成员"})
return
}
supplierID, scopeErr := server.inheritedEmployeeSupplier(request.Context(), principal, project.OrganizationID, *user, entry.SupplierID)
if scopeErr != nil {
renderValidationError(writer, validationIssue{Field: "supplierId", Message: scopeErr.Error()})
return
}
entry.SupplierID = supplierID
prepared = append(prepared, domain.ProjectMemberRecord{
ID: domain.NewID("project-member"),
OrganizationID: project.OrganizationID,
ProjectID: project.ID,
UserID: user.ID,
SupplierID: entry.SupplierID,
Roles: roles,
CreatedAt: nowISO(),
})
}
for _, member := range prepared {
if err := server.store.UpsertProjectMember(request.Context(), member); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
renderJSON(writer, http.StatusOK, projectMemberBulkResult{Created: len(prepared)})
}
func renderSupplierMutationError(w http.ResponseWriter, err error) {
var used *store.SupplierInUseError
switch {
case errors.As(err, &used):
parts := []string{}
for label, n := range used.References {
parts = append(parts, fmt.Sprintf("%s %d", label, n))
}
sort.Strings(parts)
renderJSON(w, 409, map[string]any{"code": "supplier_in_use", "error": "无法删除:仍关联" + strings.Join(parts, "、"), "references": used.References})
case errors.Is(err, store.ErrSupplierDeleting):
renderJSON(w, 409, map[string]string{"error": "供应商正在删除,不能修改"})
case errors.Is(err, store.ErrAccountMutationBusy):
renderJSON(w, 409, map[string]string{"error": "供应商正在更新,请稍后重试;持续失败请管理员检查未完成操作"})
case errors.Is(err, store.ErrSupplierNameConflict):
renderJSON(w, 409, map[string]string{"error": "供应商名称已存在"})
case errors.Is(err, store.ErrDefaultSupplierProtected):
renderJSON(w, 409, map[string]string{"error": "默认供应商由系统保留,不能修改或删除"})
case errors.Is(err, store.ErrSupplierNotFound):
renderJSON(w, 404, map[string]string{"error": "供应商不存在"})
default:
renderError(w, 500, err)
}
}
func (server *server) handleSupplierUpdate(w http.ResponseWriter, r *http.Request) {
server.mutateSupplier(w, r, false)
}
func (server *server) handleSupplierDelete(w http.ResponseWriter, r *http.Request) {
server.mutateSupplier(w, r, true)
}
func (server *server) mutateSupplier(w http.ResponseWriter, r *http.Request, remove bool) {
principal, _ := currentPrincipal(r)
if !isOrganizationAdmin(principal) {
renderJSON(w, 403, map[string]string{"error": "仅管理员可管理供应商"})
return
}
var payload supplierInput
if !remove {
if !decodeJSON(w, r, &payload) {
return
}
payload.Name = strings.TrimSpace(payload.Name)
if payload.Name == "" {
renderValidationError(w, validationIssue{Field: "name", Message: "供应商名称不能为空"})
return
}
}
item, err := server.store.MutateSupplier(r.Context(), server.requestOrganizationID(r), chi.URLParam(r, "supplierId"), payload.Name, remove)
if err != nil {
renderSupplierMutationError(w, err)
return
}
if remove {
w.WriteHeader(204)
} else {
renderJSON(w, 200, item)
}
}