forked from longtao.wu/droboticflow
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>
614 lines
24 KiB
Go
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)
|
|
}
|
|
}
|