1444 lines
53 KiB
Go
1444 lines
53 KiB
Go
package controller
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"net/http"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"github.com/QuantumNous/new-api/common"
|
||
"github.com/QuantumNous/new-api/constant"
|
||
"github.com/QuantumNous/new-api/dto"
|
||
"github.com/QuantumNous/new-api/model"
|
||
"github.com/QuantumNous/new-api/service"
|
||
"github.com/gin-gonic/gin"
|
||
)
|
||
|
||
// SupplierApplicationSubmitRequest 供应商提交申请请求体。
|
||
type SupplierApplicationSubmitRequest struct {
|
||
ApplicantUserID int `json:"applicant_user_id"`
|
||
SupplierAlias string `json:"supplier_alias"`
|
||
SupplierType string `json:"supplier_type"`
|
||
CompanyName string `json:"company_name"`
|
||
CreditCode string `json:"credit_code"`
|
||
BusinessLicenseURL string `json:"business_license_url"`
|
||
BusinessLicenseFile string `json:"business_license_file"`
|
||
CompanyLogoURL string `json:"company_logo_url"`
|
||
LegalRepresentative string `json:"legal_representative"`
|
||
CompanySize string `json:"company_size"`
|
||
ContactName string `json:"contact_name"`
|
||
ContactMobile string `json:"contact_mobile"`
|
||
ContactWechat string `json:"contact_wechat"`
|
||
}
|
||
|
||
// getSupplierApplicationMissingFieldMessage 返回供应商申请缺失字段的中文提示。
|
||
func getSupplierApplicationMissingFieldMessage(req SupplierApplicationSubmitRequest) string {
|
||
switch {
|
||
case req.CompanyName == "":
|
||
return "请填写企业/主体名称（company_name）"
|
||
case req.CreditCode == "":
|
||
return "请填写统一社会信用代码（credit_code）"
|
||
case req.BusinessLicenseURL == "":
|
||
return "请上传营业执照（business_license_url）"
|
||
case req.CompanyLogoURL == "":
|
||
return "请上传企业Logo（company_logo_url）"
|
||
case req.LegalRepresentative == "":
|
||
return "请填写法人/经营者姓名（legal_representative）"
|
||
case req.ContactName == "":
|
||
return "请填写对接人姓名（contact_name）"
|
||
case req.ContactMobile == "":
|
||
return "请填写对接人手机号（contact_mobile）"
|
||
case req.ContactWechat == "":
|
||
return "请填写对接人微信/企业微信（contact_wechat）"
|
||
default:
|
||
return ""
|
||
}
|
||
}
|
||
|
||
// SupplierApplicationReviewRequest 管理员审核请求体。
|
||
type SupplierApplicationReviewRequest struct {
|
||
Status int `json:"status"`
|
||
Reason string `json:"reason"`
|
||
SupplierAlias string `json:"supplier_alias"`
|
||
SupplierType string `json:"supplier_type"`
|
||
}
|
||
|
||
var allowedSupplierTypes = map[string]struct{}{
|
||
"公有云": {},
|
||
"AIDC": {},
|
||
"企业中转站": {},
|
||
"个人中转站": {},
|
||
}
|
||
|
||
// isValidSupplierType 判断供应商类型是否在允许枚举内。
|
||
func isValidSupplierType(supplierType string) bool {
|
||
_, ok := allowedSupplierTypes[supplierType]
|
||
return ok
|
||
}
|
||
|
||
// SupplierDeactivateRequest 供应商注销请求体。
|
||
type SupplierDeactivateRequest struct {
|
||
SupplierID int `json:"supplier_id"`
|
||
Reason string `json:"reason"`
|
||
}
|
||
|
||
// PublishUserMessageRequest 管理员发布站内消息请求体。
|
||
type PublishUserMessageRequest struct {
|
||
ReceiverUserID int `json:"receiver_user_id"`
|
||
ReceiverMinRole int `json:"receiver_min_role"`
|
||
Type string `json:"type"`
|
||
Title string `json:"title"`
|
||
Content string `json:"content"`
|
||
BizType string `json:"biz_type"`
|
||
BizID int `json:"biz_id"`
|
||
}
|
||
|
||
// SupplierApplicationUpdateRequest 供应商修改申请请求体（必须带申请ID）。
|
||
type SupplierApplicationUpdateRequest struct {
|
||
ID int `json:"id"`
|
||
SupplierApplicationSubmitRequest
|
||
}
|
||
|
||
// SupplierCapabilityUpsertRequest 供应商技术能力档案写入请求体。
|
||
type SupplierCapabilityUpsertRequest struct {
|
||
CoreServiceTypes []string `json:"core_service_types"`
|
||
SupportedModels []string `json:"supported_models"`
|
||
SupportedModelNotes string `json:"supported_model_notes"`
|
||
SupportedAPIEndpoints []string `json:"supported_api_endpoints"`
|
||
SupportedAPIEndpointExtra string `json:"supported_api_endpoint_extra"`
|
||
SupportedParams []string `json:"supported_params"`
|
||
SupportedParamsExtra string `json:"supported_params_extra"`
|
||
StreamingSupported bool `json:"streaming_supported"`
|
||
StreamingNotes string `json:"streaming_notes"`
|
||
StructuredOutputSupported bool `json:"structured_output_supported"`
|
||
StructuredOutputNotes string `json:"structured_output_notes"`
|
||
MultimodalTypes []string `json:"multimodal_types"`
|
||
MultimodalExtra string `json:"multimodal_extra"`
|
||
PricingModes []string `json:"pricing_modes"`
|
||
ReferenceInputPrice string `json:"reference_input_price"`
|
||
ReferenceOutputPrice string `json:"reference_output_price"`
|
||
FailureBillingMode string `json:"failure_billing_mode"`
|
||
FailureBillingNotes string `json:"failure_billing_notes"`
|
||
APIBaseURLs []string `json:"api_base_urls"`
|
||
OpenAICompatible bool `json:"openai_compatible"`
|
||
TruthCommitmentConfirmed bool `json:"truth_commitment_confirmed"`
|
||
}
|
||
|
||
// requireApprovedSupplierApplication 要求当前用户为审核通过供应商。
|
||
func requireApprovedSupplierApplication(c *gin.Context) (*model.SupplierApplication, bool) {
|
||
app, err := model.GetApprovedSupplierApplicationByApplicant(c.GetInt("id"))
|
||
if err != nil {
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusForbidden, gin.H{"success": false, "message": "当前用户未通过供应商审核，无法操作渠道或模型"})
|
||
return nil, false
|
||
}
|
||
common.ApiError(c, err)
|
||
return nil, false
|
||
}
|
||
return app, true
|
||
}
|
||
|
||
// readOptionalStatusQuery 读取可选 status 查询参数。
|
||
func readOptionalStatusQuery(c *gin.Context) (*int, error) {
|
||
statusRaw := strings.TrimSpace(c.Query("status"))
|
||
if statusRaw == "" {
|
||
return nil, nil
|
||
}
|
||
status, err := strconv.Atoi(statusRaw)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if status < model.SupplierApplicationStatusPending || status > model.SupplierApplicationStatusDeactivated {
|
||
return nil, errors.New("invalid status")
|
||
}
|
||
return &status, nil
|
||
}
|
||
|
||
// readSupplierStatusListQuery 读取供应商列表状态查询参数（支持逗号分隔）。
|
||
// 未传时默认返回“审核通过 + 已注销”。
|
||
func readSupplierStatusListQuery(c *gin.Context) ([]int, error) {
|
||
statusRaw := strings.TrimSpace(c.Query("status"))
|
||
if statusRaw == "" {
|
||
return []int{model.SupplierApplicationStatusApproved, model.SupplierApplicationStatusDeactivated}, nil
|
||
}
|
||
statusParts := strings.Split(statusRaw, ",")
|
||
statuses := make([]int, 0, len(statusParts))
|
||
seen := make(map[int]struct{}, len(statusParts))
|
||
for _, part := range statusParts {
|
||
part = strings.TrimSpace(part)
|
||
if part == "" {
|
||
continue
|
||
}
|
||
status, err := strconv.Atoi(part)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if status < model.SupplierApplicationStatusPending || status > model.SupplierApplicationStatusDeactivated {
|
||
return nil, errors.New("invalid status")
|
||
}
|
||
if _, ok := seen[status]; ok {
|
||
continue
|
||
}
|
||
seen[status] = struct{}{}
|
||
statuses = append(statuses, status)
|
||
}
|
||
if len(statuses) == 0 {
|
||
return nil, errors.New("empty status")
|
||
}
|
||
return statuses, nil
|
||
}
|
||
|
||
// trimAndFilterStrings 清理字符串数组中的空白项。
|
||
func trimAndFilterStrings(values []string) []string {
|
||
cleaned := make([]string, 0, len(values))
|
||
for _, item := range values {
|
||
trimmed := strings.TrimSpace(item)
|
||
if trimmed == "" {
|
||
continue
|
||
}
|
||
cleaned = append(cleaned, trimmed)
|
||
}
|
||
return cleaned
|
||
}
|
||
|
||
// marshalStringArray 将字符串数组编码为 JSON 字符串。
|
||
func marshalStringArray(values []string) (string, error) {
|
||
bytes, err := common.Marshal(trimAndFilterStrings(values))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return string(bytes), nil
|
||
}
|
||
|
||
// unmarshalStringArray 将 JSON 字符串解码为字符串数组。
|
||
func unmarshalStringArray(raw string) []string {
|
||
raw = strings.TrimSpace(raw)
|
||
if raw == "" {
|
||
return []string{}
|
||
}
|
||
var items []string
|
||
if err := common.UnmarshalJsonStr(raw, &items); err != nil {
|
||
return []string{}
|
||
}
|
||
return trimAndFilterStrings(items)
|
||
}
|
||
|
||
// buildSupplierCapabilityModel 将请求体转换为模型对象。
|
||
func buildSupplierCapabilityModel(req *SupplierCapabilityUpsertRequest) (*model.SupplierCapability, error) {
|
||
coreServiceTypes, err := marshalStringArray(req.CoreServiceTypes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
supportedModels, err := marshalStringArray(req.SupportedModels)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
supportedAPIEndpoints, err := marshalStringArray(req.SupportedAPIEndpoints)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
supportedParams, err := marshalStringArray(req.SupportedParams)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
multimodalTypes, err := marshalStringArray(req.MultimodalTypes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
pricingModes, err := marshalStringArray(req.PricingModes)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
apiBaseURLs, err := marshalStringArray(req.APIBaseURLs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &model.SupplierCapability{
|
||
CoreServiceTypes: coreServiceTypes,
|
||
SupportedModels: supportedModels,
|
||
SupportedModelNotes: strings.TrimSpace(req.SupportedModelNotes),
|
||
SupportedAPIEndpoints: supportedAPIEndpoints,
|
||
SupportedAPIEndpointExtra: strings.TrimSpace(req.SupportedAPIEndpointExtra),
|
||
SupportedParams: supportedParams,
|
||
SupportedParamsExtra: strings.TrimSpace(req.SupportedParamsExtra),
|
||
StreamingSupported: req.StreamingSupported,
|
||
StreamingNotes: strings.TrimSpace(req.StreamingNotes),
|
||
StructuredOutputSupported: req.StructuredOutputSupported,
|
||
StructuredOutputNotes: strings.TrimSpace(req.StructuredOutputNotes),
|
||
MultimodalTypes: multimodalTypes,
|
||
MultimodalExtra: strings.TrimSpace(req.MultimodalExtra),
|
||
PricingModes: pricingModes,
|
||
ReferenceInputPrice: strings.TrimSpace(req.ReferenceInputPrice),
|
||
ReferenceOutputPrice: strings.TrimSpace(req.ReferenceOutputPrice),
|
||
FailureBillingMode: strings.TrimSpace(req.FailureBillingMode),
|
||
FailureBillingNotes: strings.TrimSpace(req.FailureBillingNotes),
|
||
APIBaseURLs: apiBaseURLs,
|
||
OpenAICompatible: req.OpenAICompatible,
|
||
TruthCommitmentConfirmed: req.TruthCommitmentConfirmed,
|
||
}, nil
|
||
}
|
||
|
||
// buildSupplierCapabilityResponse 将模型对象转换为接口响应对象。
|
||
func buildSupplierCapabilityResponse(capability *model.SupplierCapability) gin.H {
|
||
if capability == nil {
|
||
return nil
|
||
}
|
||
return gin.H{
|
||
"id": capability.ID,
|
||
"supplier_application_id": capability.SupplierApplicationID,
|
||
"core_service_types": unmarshalStringArray(capability.CoreServiceTypes),
|
||
"supported_models": unmarshalStringArray(capability.SupportedModels),
|
||
"supported_model_notes": capability.SupportedModelNotes,
|
||
"supported_api_endpoints": unmarshalStringArray(capability.SupportedAPIEndpoints),
|
||
"supported_api_endpoint_extra": capability.SupportedAPIEndpointExtra,
|
||
"supported_params": unmarshalStringArray(capability.SupportedParams),
|
||
"supported_params_extra": capability.SupportedParamsExtra,
|
||
"streaming_supported": capability.StreamingSupported,
|
||
"streaming_notes": capability.StreamingNotes,
|
||
"structured_output_supported": capability.StructuredOutputSupported,
|
||
"structured_output_notes": capability.StructuredOutputNotes,
|
||
"multimodal_types": unmarshalStringArray(capability.MultimodalTypes),
|
||
"multimodal_extra": capability.MultimodalExtra,
|
||
"pricing_modes": unmarshalStringArray(capability.PricingModes),
|
||
"reference_input_price": capability.ReferenceInputPrice,
|
||
"reference_output_price": capability.ReferenceOutputPrice,
|
||
"failure_billing_mode": capability.FailureBillingMode,
|
||
"failure_billing_notes": capability.FailureBillingNotes,
|
||
"api_base_urls": unmarshalStringArray(capability.APIBaseURLs),
|
||
"openai_compatible": capability.OpenAICompatible,
|
||
"truth_commitment_confirmed": capability.TruthCommitmentConfirmed,
|
||
"created_at": capability.CreatedAt,
|
||
"updated_at": capability.UpdatedAt,
|
||
}
|
||
}
|
||
|
||
// attachSupplierCapability 为供应商申请对象补充技术能力档案。
|
||
func attachSupplierCapability(app *model.SupplierApplication) error {
|
||
if app == nil {
|
||
return nil
|
||
}
|
||
capability, err := model.GetSupplierCapabilityByApplicationID(app.ID)
|
||
if err != nil {
|
||
if model.IsSupplierCapabilityNotFound(err) {
|
||
app.SupplierCapability = nil
|
||
return nil
|
||
}
|
||
return err
|
||
}
|
||
app.SupplierCapability = capability
|
||
return nil
|
||
}
|
||
|
||
// SubmitSupplierApplication godoc
|
||
// @Summary 提交供应商入驻申请
|
||
// @Description 普通用户提交供应商申请，提交后生成管理员待审核站内消息
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body SupplierApplicationSubmitRequest true "申请信息"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application [post]
|
||
func SubmitSupplierApplication(c *gin.Context) {
|
||
var req SupplierApplicationSubmitRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
req.CompanyName = strings.TrimSpace(req.CompanyName)
|
||
req.CreditCode = strings.TrimSpace(req.CreditCode)
|
||
req.BusinessLicenseURL = strings.TrimSpace(req.BusinessLicenseURL)
|
||
req.BusinessLicenseFile = strings.TrimSpace(req.BusinessLicenseFile)
|
||
req.CompanyLogoURL = strings.TrimSpace(req.CompanyLogoURL)
|
||
req.SupplierType = strings.TrimSpace(req.SupplierType)
|
||
req.LegalRepresentative = strings.TrimSpace(req.LegalRepresentative)
|
||
req.CompanySize = strings.TrimSpace(req.CompanySize)
|
||
req.ContactName = strings.TrimSpace(req.ContactName)
|
||
req.ContactMobile = strings.TrimSpace(req.ContactMobile)
|
||
req.ContactWechat = strings.TrimSpace(req.ContactWechat)
|
||
if missingFieldMessage := getSupplierApplicationMissingFieldMessage(req); missingFieldMessage != "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": missingFieldMessage})
|
||
return
|
||
}
|
||
if len(req.CreditCode) != 18 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "统一社会信用代码需为18位"})
|
||
return
|
||
}
|
||
|
||
isAdminOrAbove := c.GetInt("role") >= common.RoleAdminUser
|
||
applicantUserID := c.GetInt("id")
|
||
if isAdminOrAbove {
|
||
if req.SupplierType == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "管理员代添加供应商时必须选择供应商类型"})
|
||
return
|
||
}
|
||
if !isValidSupplierType(req.SupplierType) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商类型"})
|
||
return
|
||
}
|
||
if req.ApplicantUserID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "管理员代添加供应商时必须提供有效的applicant_user_id"})
|
||
return
|
||
}
|
||
if _, err := model.GetUserById(req.ApplicantUserID, false); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "指定的关联用户不存在"})
|
||
return
|
||
}
|
||
applicantUserID = req.ApplicantUserID
|
||
}
|
||
app := &model.SupplierApplication{
|
||
ApplicantUserID: applicantUserID,
|
||
CompanyName: req.CompanyName,
|
||
CreditCode: req.CreditCode,
|
||
BusinessLicenseURL: req.BusinessLicenseURL,
|
||
BusinessLicenseFile: req.BusinessLicenseFile,
|
||
CompanyLogoURL: req.CompanyLogoURL,
|
||
SupplierType: req.SupplierType,
|
||
LegalRepresentative: req.LegalRepresentative,
|
||
CompanySize: req.CompanySize,
|
||
ContactName: req.ContactName,
|
||
ContactMobile: req.ContactMobile,
|
||
ContactWechat: req.ContactWechat,
|
||
}
|
||
var err error
|
||
if isAdminOrAbove {
|
||
err = model.CreateSupplierApplicationAutoApproved(app, c.GetInt("id"))
|
||
} else {
|
||
app.Status = model.SupplierApplicationStatusPending
|
||
err = model.CreateSupplierApplication(app)
|
||
}
|
||
if err != nil {
|
||
if model.IsSupplierCreditCodeDuplicateError(err) {
|
||
common.ApiErrorMsg(c, "统一社会信用代码已存在，请核对后重试")
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if !isAdminOrAbove {
|
||
_ = model.CreateSupplierApplicationAudit(&model.SupplierApplicationAudit{
|
||
ApplicationID: app.ID,
|
||
OperatorUserID: app.ApplicantUserID,
|
||
Action: model.SupplierApplicationAuditActionSubmit,
|
||
FromStatus: model.SupplierApplicationStatusPending,
|
||
ToStatus: model.SupplierApplicationStatusPending,
|
||
Reason: "",
|
||
})
|
||
_ = service.PublishUserMessage(&model.UserMessage{
|
||
ReceiverUserID: 0,
|
||
ReceiverMinRole: common.RoleAdminUser,
|
||
Type: model.UserMessageTypeSupplierSubmitted,
|
||
Title: "供应商入驻待审核",
|
||
Content: fmt.Sprintf("收到新的供应商申请：%s（统一社会信用代码：%s）", app.CompanyName, app.CreditCode),
|
||
BizType: model.UserMessageBizTypeSupplierApplication,
|
||
BizID: app.ID,
|
||
})
|
||
}
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// GetMySupplierApplication godoc
|
||
// @Summary 查询当前用户供应商申请
|
||
// @Tags Supplier
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Success 200 {object} map[string]interface{} "success + data{申请对象或null}"
|
||
// @Router /user/supplier/application/self [get]
|
||
func GetMySupplierApplication(c *gin.Context) {
|
||
app, err := model.GetMySupplierApplication(c.GetInt("id"))
|
||
if err != nil {
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
common.ApiSuccess(c, nil)
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if err = attachSupplierCapability(app); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
response := gin.H{
|
||
"id": app.ID,
|
||
"applicant_user_id": app.ApplicantUserID,
|
||
"company_name": app.CompanyName,
|
||
"credit_code": app.CreditCode,
|
||
"business_license_url": app.BusinessLicenseURL,
|
||
"business_license_file": app.BusinessLicenseFile,
|
||
"company_logo_url": app.CompanyLogoURL,
|
||
"supplier_type": app.SupplierType,
|
||
"legal_representative": app.LegalRepresentative,
|
||
"company_size": app.CompanySize,
|
||
"contact_name": app.ContactName,
|
||
"contact_mobile": app.ContactMobile,
|
||
"contact_wechat": app.ContactWechat,
|
||
"supplier_alias": app.SupplierAlias,
|
||
"status": app.Status,
|
||
"review_reason": app.ReviewReason,
|
||
"reviewed_by": app.ReviewedBy,
|
||
"reviewed_at": app.ReviewedAt,
|
||
"created_at": app.CreatedAt,
|
||
"updated_at": app.UpdatedAt,
|
||
"supplier_capability": buildSupplierCapabilityResponse(app.SupplierCapability),
|
||
}
|
||
common.ApiSuccess(c, response)
|
||
}
|
||
|
||
// GetSupplierCapability godoc
|
||
// @Summary 查询供应商技术能力档案
|
||
// @Description 管理员可查任意申请；普通用户仅可查询自己的申请
|
||
// @Tags Supplier
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "供应商申请ID"
|
||
// @Success 200 {object} map[string]interface{} "success + data{供应商技术能力档案}"
|
||
// @Router /user/supplier/application/{id}/capability [get]
|
||
func GetSupplierCapability(c *gin.Context) {
|
||
applicationID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || applicationID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商申请ID"})
|
||
return
|
||
}
|
||
app, err := model.GetSupplierByID(applicationID)
|
||
if err != nil {
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到供应商申请"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if c.GetInt("role") < common.RoleAdminUser && app.ApplicantUserID != c.GetInt("id") {
|
||
c.JSON(http.StatusForbidden, gin.H{"success": false, "message": "无权查看该供应商技术能力档案"})
|
||
return
|
||
}
|
||
capability, err := model.GetSupplierCapabilityByApplicationID(applicationID)
|
||
if err != nil {
|
||
if model.IsSupplierCapabilityNotFound(err) {
|
||
common.ApiSuccess(c, nil)
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, buildSupplierCapabilityResponse(capability))
|
||
}
|
||
|
||
// UpsertSupplierCapability godoc
|
||
// @Summary 保存供应商技术能力档案
|
||
// @Description 管理员可保存任意申请；普通用户仅可保存自己的申请
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "供应商申请ID"
|
||
// @Param request body SupplierCapabilityUpsertRequest true "供应商技术能力档案"
|
||
// @Success 200 {object} map[string]interface{} "success + data{供应商技术能力档案}"
|
||
// @Router /user/supplier/application/{id}/capability [put]
|
||
func UpsertSupplierCapability(c *gin.Context) {
|
||
applicationID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || applicationID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商申请ID"})
|
||
return
|
||
}
|
||
app, err := model.GetSupplierByID(applicationID)
|
||
if err != nil {
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到供应商申请"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if c.GetInt("role") < common.RoleAdminUser && app.ApplicantUserID != c.GetInt("id") {
|
||
c.JSON(http.StatusForbidden, gin.H{"success": false, "message": "无权修改该供应商技术能力档案"})
|
||
return
|
||
}
|
||
var req SupplierCapabilityUpsertRequest
|
||
if err = c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
capabilityModel, err := buildSupplierCapabilityModel(&req)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
updated, err := model.UpsertSupplierCapabilityByApplicationID(applicationID, capabilityModel)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, buildSupplierCapabilityResponse(updated))
|
||
}
|
||
|
||
// UpdateMySupplierApplication godoc
|
||
// @Summary 修改当前用户供应商申请并重新提交
|
||
// @Description 当前申请只要未审核通过都可修改，修改后状态重置为待审核(0)
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body SupplierApplicationUpdateRequest true "申请信息（含id）"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application/self [put]
|
||
func UpdateMySupplierApplication(c *gin.Context) {
|
||
var req SupplierApplicationUpdateRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
if req.ID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "修改申请时必须提供有效的id"})
|
||
return
|
||
}
|
||
req.CompanyName = strings.TrimSpace(req.CompanyName)
|
||
req.CreditCode = strings.TrimSpace(req.CreditCode)
|
||
req.BusinessLicenseURL = strings.TrimSpace(req.BusinessLicenseURL)
|
||
req.BusinessLicenseFile = strings.TrimSpace(req.BusinessLicenseFile)
|
||
req.CompanyLogoURL = strings.TrimSpace(req.CompanyLogoURL)
|
||
req.SupplierType = strings.TrimSpace(req.SupplierType)
|
||
req.LegalRepresentative = strings.TrimSpace(req.LegalRepresentative)
|
||
req.CompanySize = strings.TrimSpace(req.CompanySize)
|
||
req.ContactName = strings.TrimSpace(req.ContactName)
|
||
req.ContactMobile = strings.TrimSpace(req.ContactMobile)
|
||
req.ContactWechat = strings.TrimSpace(req.ContactWechat)
|
||
if req.CompanyName == "" || req.CreditCode == "" || req.BusinessLicenseURL == "" || req.CompanyLogoURL == "" ||
|
||
req.LegalRepresentative == "" || req.ContactName == "" || req.ContactMobile == "" || req.ContactWechat == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "请填写完整的必填字段"})
|
||
return
|
||
}
|
||
if len(req.CreditCode) != 18 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "统一社会信用代码需为18位"})
|
||
return
|
||
}
|
||
app, err := model.UpdateMySupplierApplication(c.GetInt("id"), req.ID, &model.SupplierApplication{
|
||
CompanyName: req.CompanyName,
|
||
CreditCode: req.CreditCode,
|
||
BusinessLicenseURL: req.BusinessLicenseURL,
|
||
BusinessLicenseFile: req.BusinessLicenseFile,
|
||
CompanyLogoURL: req.CompanyLogoURL,
|
||
SupplierType: req.SupplierType,
|
||
LegalRepresentative: req.LegalRepresentative,
|
||
CompanySize: req.CompanySize,
|
||
ContactName: req.ContactName,
|
||
ContactMobile: req.ContactMobile,
|
||
ContactWechat: req.ContactWechat,
|
||
})
|
||
if err != nil {
|
||
if model.IsSupplierCreditCodeDuplicateError(err) {
|
||
common.ApiErrorMsg(c, "统一社会信用代码已存在，请核对后重试")
|
||
return
|
||
}
|
||
if errors.Is(err, model.ErrSupplierApplicationStatusNotEditable) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "当前申请状态不可修改"})
|
||
return
|
||
}
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到可修改的供应商申请"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
_ = service.PublishUserMessage(&model.UserMessage{
|
||
ReceiverUserID: 0,
|
||
ReceiverMinRole: common.RoleAdminUser,
|
||
Type: model.UserMessageTypeSupplierSubmitted,
|
||
Title: "供应商入驻待审核",
|
||
Content: fmt.Sprintf("供应商申请已更新并重新提交：%s（统一社会信用代码：%s）", app.CompanyName, app.CreditCode),
|
||
BizType: model.UserMessageBizTypeSupplierApplication,
|
||
BizID: app.ID,
|
||
})
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// AdminListSupplierApplications godoc
|
||
// @Summary 管理员分页查询供应商申请
|
||
// @Tags SupplierAdmin
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param p query int false "页码"
|
||
// @Param page_size query int false "每页数量"
|
||
// @Param status query int false "状态：0待审核 1审核通过 2审核驳回"
|
||
// @Success 200 {object} map[string]interface{} "分页结果"
|
||
// @Router /user/supplier/application [get]
|
||
func AdminListSupplierApplications(c *gin.Context) {
|
||
status, err := readOptionalStatusQuery(c)
|
||
if err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的status参数"})
|
||
return
|
||
}
|
||
pageInfo := common.GetPageQuery(c)
|
||
items, total, err := model.ListSupplierApplications(status, pageInfo)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
pageInfo.SetTotal(int(total))
|
||
pageInfo.SetItems(items)
|
||
common.ApiSuccess(c, pageInfo)
|
||
}
|
||
|
||
// AdminListSuppliers godoc
|
||
// @Summary 管理员分页查询供应商列表
|
||
// @Description 支持按供应商名称模糊查询，返回分页数据
|
||
// @Tags SupplierAdmin
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param p query int false "页码"
|
||
// @Param page_size query int false "每页数量"
|
||
// @Param company_name query string false "供应商名称（模糊）"
|
||
// @Param status query string false "状态筛选，支持逗号分隔（如1,3）；默认查询1和3"
|
||
// @Success 200 {object} map[string]interface{} "分页结果"
|
||
// @Router /user/supplier/list [get]
|
||
func AdminListSuppliers(c *gin.Context) {
|
||
pageInfo := common.GetPageQuery(c)
|
||
companyName := strings.TrimSpace(c.Query("company_name"))
|
||
statuses, err := readSupplierStatusListQuery(c)
|
||
if err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的status参数"})
|
||
return
|
||
}
|
||
items, total, err := model.ListSuppliersByCompanyName(companyName, statuses, pageInfo)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
pageInfo.SetTotal(int(total))
|
||
pageInfo.SetItems(items)
|
||
common.ApiSuccess(c, pageInfo)
|
||
}
|
||
|
||
// AdminGetSupplierDetail godoc
|
||
// @Summary 管理员查询供应商详情
|
||
// @Description 根据供应商ID查询供应商详情，返回申请人用户名 applicant_username
|
||
// @Tags SupplierAdmin
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "供应商ID"
|
||
// @Success 200 {object} map[string]interface{} "供应商详情"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/{id} [get]
|
||
func AdminGetSupplierDetail(c *gin.Context) {
|
||
supplierID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || supplierID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商ID"})
|
||
return
|
||
}
|
||
item, err := model.GetSupplierByID(supplierID)
|
||
if err != nil {
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到供应商信息"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if err = attachSupplierCapability(item); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
response := gin.H{
|
||
"id": item.ID,
|
||
"applicant_user_id": item.ApplicantUserID,
|
||
"applicant_username": item.ApplicantUsername,
|
||
"company_name": item.CompanyName,
|
||
"credit_code": item.CreditCode,
|
||
"business_license_url": item.BusinessLicenseURL,
|
||
"business_license_file": item.BusinessLicenseFile,
|
||
"company_logo_url": item.CompanyLogoURL,
|
||
"supplier_type": item.SupplierType,
|
||
"legal_representative": item.LegalRepresentative,
|
||
"company_size": item.CompanySize,
|
||
"contact_name": item.ContactName,
|
||
"contact_mobile": item.ContactMobile,
|
||
"contact_wechat": item.ContactWechat,
|
||
"supplier_alias": item.SupplierAlias,
|
||
"status": item.Status,
|
||
"review_reason": item.ReviewReason,
|
||
"reviewed_by": item.ReviewedBy,
|
||
"reviewed_at": item.ReviewedAt,
|
||
"created_at": item.CreatedAt,
|
||
"updated_at": item.UpdatedAt,
|
||
"supplier_capability": buildSupplierCapabilityResponse(item.SupplierCapability),
|
||
}
|
||
common.ApiSuccess(c, response)
|
||
}
|
||
|
||
// AdminUpdateSupplierApplication godoc
|
||
// @Summary 管理员修改供应商申请资料
|
||
// @Description 管理员可修改任意供应商申请资料；审核通过(status=1)状态也允许修改，且修改后保持原状态
|
||
// @Tags SupplierAdmin
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "供应商申请ID"
|
||
// @Param request body SupplierApplicationSubmitRequest true "申请信息"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application/{id} [put]
|
||
func AdminUpdateSupplierApplication(c *gin.Context) {
|
||
applicationID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || applicationID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商申请ID"})
|
||
return
|
||
}
|
||
var req SupplierApplicationSubmitRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
req.CompanyName = strings.TrimSpace(req.CompanyName)
|
||
req.CreditCode = strings.TrimSpace(req.CreditCode)
|
||
req.BusinessLicenseURL = strings.TrimSpace(req.BusinessLicenseURL)
|
||
req.BusinessLicenseFile = strings.TrimSpace(req.BusinessLicenseFile)
|
||
req.CompanyLogoURL = strings.TrimSpace(req.CompanyLogoURL)
|
||
req.SupplierType = strings.TrimSpace(req.SupplierType)
|
||
req.LegalRepresentative = strings.TrimSpace(req.LegalRepresentative)
|
||
req.CompanySize = strings.TrimSpace(req.CompanySize)
|
||
req.ContactName = strings.TrimSpace(req.ContactName)
|
||
req.ContactMobile = strings.TrimSpace(req.ContactMobile)
|
||
req.ContactWechat = strings.TrimSpace(req.ContactWechat)
|
||
req.SupplierAlias = strings.TrimSpace(req.SupplierAlias)
|
||
if req.CompanyName == "" || req.CreditCode == "" || req.BusinessLicenseURL == "" || req.CompanyLogoURL == "" ||
|
||
req.LegalRepresentative == "" || req.ContactName == "" || req.ContactMobile == "" || req.ContactWechat == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "请填写完整的必填字段"})
|
||
return
|
||
}
|
||
if req.SupplierType == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "请填写供应商类型"})
|
||
return
|
||
}
|
||
if !isValidSupplierType(req.SupplierType) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商类型"})
|
||
return
|
||
}
|
||
if len(req.CreditCode) != 18 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "统一社会信用代码需为18位"})
|
||
return
|
||
}
|
||
aliasPtr := req.SupplierAlias
|
||
app, err := model.AdminUpdateSupplierApplication(applicationID, &model.SupplierApplication{
|
||
CompanyName: req.CompanyName,
|
||
CreditCode: req.CreditCode,
|
||
BusinessLicenseURL: req.BusinessLicenseURL,
|
||
BusinessLicenseFile: req.BusinessLicenseFile,
|
||
CompanyLogoURL: req.CompanyLogoURL,
|
||
SupplierType: req.SupplierType,
|
||
LegalRepresentative: req.LegalRepresentative,
|
||
CompanySize: req.CompanySize,
|
||
ContactName: req.ContactName,
|
||
ContactMobile: req.ContactMobile,
|
||
ContactWechat: req.ContactWechat,
|
||
SupplierAlias: &aliasPtr,
|
||
})
|
||
if err != nil {
|
||
if model.IsSupplierCreditCodeDuplicateError(err) {
|
||
common.ApiErrorMsg(c, "统一社会信用代码已存在，请核对后重试")
|
||
return
|
||
}
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到可修改的供应商申请"})
|
||
return
|
||
}
|
||
if model.IsSupplierAliasDuplicateError(err) {
|
||
common.ApiErrorMsg(c, "供应商别名已存在，请更换后重试")
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// AdminReviewSupplierApplication godoc
|
||
// @Summary 管理员审核供应商申请
|
||
// @Description 任一管理员可审核一次，仅待审核状态允许处理
|
||
// @Tags SupplierAdmin
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "申请ID"
|
||
// @Param request body SupplierApplicationReviewRequest true "审核信息"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application/{id}/review [post]
|
||
func AdminReviewSupplierApplication(c *gin.Context) {
|
||
applicationID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || applicationID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的申请ID"})
|
||
return
|
||
}
|
||
var req SupplierApplicationReviewRequest
|
||
if err = c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
if req.Status != model.SupplierApplicationStatusApproved && req.Status != model.SupplierApplicationStatusRejected {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "审核状态仅支持通过或驳回"})
|
||
return
|
||
}
|
||
req.Reason = strings.TrimSpace(req.Reason)
|
||
req.SupplierType = strings.TrimSpace(req.SupplierType)
|
||
if req.Status == model.SupplierApplicationStatusRejected && req.Reason == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "驳回时请填写原因"})
|
||
return
|
||
}
|
||
if req.Status == model.SupplierApplicationStatusApproved {
|
||
capability, capabilityErr := model.GetSupplierCapabilityByApplicationID(applicationID)
|
||
if capabilityErr != nil {
|
||
if model.IsSupplierCapabilityNotFound(capabilityErr) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "审批通过前请先完善供应商技术能力信息"})
|
||
return
|
||
}
|
||
common.ApiError(c, capabilityErr)
|
||
return
|
||
}
|
||
if !model.IsSupplierCapabilityComplete(capability) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "审批通过前请先完善供应商技术能力必填字段"})
|
||
return
|
||
}
|
||
}
|
||
|
||
req.SupplierAlias = strings.TrimSpace(req.SupplierAlias)
|
||
if req.Status == model.SupplierApplicationStatusApproved {
|
||
if req.SupplierType == "" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "审批通过时必须选择供应商类型"})
|
||
return
|
||
}
|
||
if !isValidSupplierType(req.SupplierType) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的供应商类型"})
|
||
return
|
||
}
|
||
}
|
||
app, err := model.ReviewSupplierApplication(applicationID, c.GetInt("id"), req.Status, req.Reason, req.SupplierAlias, req.SupplierType)
|
||
if err != nil {
|
||
if errors.Is(err, model.ErrSupplierApplicationAlreadyReviewed) {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": "该申请已被其他管理员处理"})
|
||
return
|
||
}
|
||
if model.IsSupplierAliasDuplicateError(err) {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": "供应商别名已存在，请更换后重试"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
|
||
msgType := model.UserMessageTypeSupplierApproved
|
||
msgTitle := "供应商入驻审核通过"
|
||
msgContent := fmt.Sprintf("你的供应商申请“%s”已审核通过。", app.CompanyName)
|
||
if app.Status == model.SupplierApplicationStatusRejected {
|
||
msgType = model.UserMessageTypeSupplierRejected
|
||
msgTitle = "供应商入驻审核驳回"
|
||
msgContent = fmt.Sprintf("你的供应商申请“%s”已驳回，原因：%s", app.CompanyName, req.Reason)
|
||
}
|
||
_ = service.PublishUserMessage(&model.UserMessage{
|
||
ReceiverUserID: app.ApplicantUserID,
|
||
ReceiverMinRole: 0,
|
||
Type: msgType,
|
||
Title: msgTitle,
|
||
Content: msgContent,
|
||
BizType: model.UserMessageBizTypeSupplierApplication,
|
||
BizID: app.ID,
|
||
})
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// ListMyMessages godoc
|
||
// @Summary 查询当前用户站内消息
|
||
// @Tags Message
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param p query int false "页码"
|
||
// @Param page_size query int false "每页数量"
|
||
// @Param title query string false "标题模糊查询"
|
||
// @Param read_status query string false "读取状态：all/read/unread，默认all"
|
||
// @Success 200 {object} map[string]interface{} "分页结果"
|
||
// @Router /user/messages/self [get]
|
||
func ListMyMessages(c *gin.Context) {
|
||
pageInfo := common.GetPageQuery(c)
|
||
userID := c.GetInt("id")
|
||
role := c.GetInt("role")
|
||
titleKeyword := strings.TrimSpace(c.Query("title"))
|
||
readStatus := strings.TrimSpace(c.Query("read_status"))
|
||
if readStatus == "" {
|
||
readStatus = "all"
|
||
}
|
||
if readStatus != "all" && readStatus != "read" && readStatus != "unread" {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的read_status参数"})
|
||
return
|
||
}
|
||
items, total, err := model.ListUserMessagesForUser(userID, role, pageInfo, titleKeyword, readStatus)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
pageInfo.SetTotal(int(total))
|
||
pageInfo.SetItems(items)
|
||
common.ApiSuccess(c, pageInfo)
|
||
}
|
||
|
||
// MarkMyMessageRead godoc
|
||
// @Summary 标记当前用户消息为已读
|
||
// @Tags Message
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param id path int true "消息ID"
|
||
// @Success 200 {object} map[string]interface{} "success + data{updated}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/messages/{id}/read [post]
|
||
func MarkMyMessageRead(c *gin.Context) {
|
||
messageID, err := strconv.Atoi(c.Param("id"))
|
||
if err != nil || messageID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的消息ID"})
|
||
return
|
||
}
|
||
ok, err := model.MarkUserMessageAsRead(messageID, c.GetInt("id"), c.GetInt("role"))
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, gin.H{"updated": ok})
|
||
}
|
||
|
||
// MarkAllMyMessagesRead godoc
|
||
// @Summary 标记当前用户全部站内消息为已读
|
||
// @Tags Message
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Success 200 {object} map[string]interface{} "success + data{updated_count}"
|
||
// @Router /user/messages/read_all [post]
|
||
func MarkAllMyMessagesRead(c *gin.Context) {
|
||
updatedCount, err := model.MarkAllUserMessagesAsRead(c.GetInt("id"), c.GetInt("role"))
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, gin.H{"updated_count": updatedCount})
|
||
}
|
||
|
||
// AdminPublishUserMessage godoc
|
||
// @Summary 管理员发布站内消息
|
||
// @Description 支持按指定用户或按最小角色发布站内消息，至少设置 receiver_user_id 或 receiver_min_role 之一
|
||
// @Tags MessageAdmin
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body PublishUserMessageRequest true "消息内容"
|
||
// @Success 200 {object} map[string]interface{} "success + data{published:true}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/messages/publish [post]
|
||
func AdminPublishUserMessage(c *gin.Context) {
|
||
var req PublishUserMessageRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
if req.ReceiverUserID <= 0 && req.ReceiverMinRole <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "请至少指定接收用户或角色门槛"})
|
||
return
|
||
}
|
||
msg := &model.UserMessage{
|
||
ReceiverUserID: req.ReceiverUserID,
|
||
ReceiverMinRole: req.ReceiverMinRole,
|
||
Type: req.Type,
|
||
Title: req.Title,
|
||
Content: req.Content,
|
||
BizType: req.BizType,
|
||
BizID: req.BizID,
|
||
}
|
||
if err := service.PublishUserMessage(msg); err != nil {
|
||
common.ApiErrorMsg(c, err.Error())
|
||
return
|
||
}
|
||
common.ApiSuccess(c, gin.H{"published": true})
|
||
}
|
||
|
||
// GetMyUnreadMessageCount godoc
|
||
// @Summary 获取当前用户未读站内消息数量
|
||
// @Tags Message
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Success 200 {object} map[string]interface{} "success + data{unread_count}"
|
||
// @Router /user/messages/unread_count [get]
|
||
func GetMyUnreadMessageCount(c *gin.Context) {
|
||
total, err := model.CountUnreadUserMessages(c.GetInt("id"), c.GetInt("role"))
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
common.ApiSuccess(c, gin.H{"unread_count": total})
|
||
}
|
||
|
||
// DeactivateMySupplierApplication godoc
|
||
// @Summary 当前供应商注销
|
||
// @Description 仅审核通过状态可注销；注销后清空用户表 supplier_id 并将申请状态置为已注销
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body SupplierDeactivateRequest false "注销说明"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application/deactivate [post]
|
||
func DeactivateMySupplierApplication(c *gin.Context) {
|
||
var req SupplierDeactivateRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
if req.SupplierID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "注销供应商时必须提供有效的supplier_id"})
|
||
return
|
||
}
|
||
reason := strings.TrimSpace(req.Reason)
|
||
app, err := model.DeactivateSupplierApplication(c.GetInt("id"), c.GetInt("role"), req.SupplierID, reason)
|
||
if err != nil {
|
||
if errors.Is(err, model.ErrSupplierApplicationStatusNotApproved) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "当前供应商状态不支持注销"})
|
||
return
|
||
}
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到可注销的供应商申请"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
_ = service.PublishUserMessage(&model.UserMessage{
|
||
ReceiverUserID: 0,
|
||
ReceiverMinRole: common.RoleAdminUser,
|
||
Type: model.UserMessageTypeSupplierRejected,
|
||
Title: "供应商已注销",
|
||
Content: fmt.Sprintf("供应商“%s”已注销。", app.CompanyName),
|
||
BizType: model.UserMessageBizTypeSupplierApplication,
|
||
BizID: app.ID,
|
||
})
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// ActivateSupplierApplication godoc
|
||
// @Summary 管理员启用已注销供应商
|
||
// @Description 仅已注销状态可启用；启用后回填用户表 supplier_id 并将申请状态置为审核通过
|
||
// @Tags SupplierAdmin
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body SupplierDeactivateRequest false "启用说明"
|
||
// @Success 200 {object} map[string]interface{} "success + data{id,status}"
|
||
// @Failure 400 {object} map[string]interface{} "参数错误"
|
||
// @Router /user/supplier/application/activate [post]
|
||
func ActivateSupplierApplication(c *gin.Context) {
|
||
var req SupplierDeactivateRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "无效的参数"})
|
||
return
|
||
}
|
||
if req.SupplierID <= 0 {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "启用供应商时必须提供有效的supplier_id"})
|
||
return
|
||
}
|
||
reason := strings.TrimSpace(req.Reason)
|
||
app, err := model.ActivateSupplierApplication(c.GetInt("id"), c.GetInt("role"), req.SupplierID, reason)
|
||
if err != nil {
|
||
if errors.Is(err, model.ErrSupplierApplicationStatusNotDeactivated) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "当前供应商状态不支持启用"})
|
||
return
|
||
}
|
||
if model.IsSupplierApplicationNotFound(err) {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "未找到可启用的供应商申请"})
|
||
return
|
||
}
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
_ = service.PublishUserMessage(&model.UserMessage{
|
||
ReceiverUserID: app.ApplicantUserID,
|
||
ReceiverMinRole: 0,
|
||
Type: model.UserMessageTypeSupplierApproved,
|
||
Title: "供应商已启用",
|
||
Content: fmt.Sprintf("你的供应商“%s”已重新启用。", app.CompanyName),
|
||
BizType: model.UserMessageBizTypeSupplierApplication,
|
||
BizID: app.ID,
|
||
})
|
||
common.ApiSuccess(c, gin.H{
|
||
"id": app.ID,
|
||
"status": app.Status,
|
||
})
|
||
}
|
||
|
||
// CreateMySupplierChannel godoc
|
||
// @Summary 当前供应商新增渠道
|
||
// @Description 仅审核通过的供应商可新增，自动写入 owner_user_id 与 supplier_application_id
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body AddChannelRequest true "渠道创建参数"
|
||
// @Success 200 {object} map[string]interface{} "创建结果"
|
||
// @Router /user/supplier/channels [post]
|
||
func CreateMySupplierChannel(c *gin.Context) {
|
||
supplierApp, ok := requireApprovedSupplierApplication(c)
|
||
if !ok {
|
||
return
|
||
}
|
||
addChannelRequest := AddChannelRequest{}
|
||
if err := c.ShouldBindJSON(&addChannelRequest); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if err := validateChannel(addChannelRequest.Channel, true); err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
|
||
return
|
||
}
|
||
addChannelRequest.Channel.CreatedTime = common.GetTimestamp()
|
||
keys := make([]string, 0)
|
||
switch addChannelRequest.Mode {
|
||
case "multi_to_single":
|
||
addChannelRequest.Channel.ChannelInfo.IsMultiKey = true
|
||
addChannelRequest.Channel.ChannelInfo.MultiKeyMode = addChannelRequest.MultiKeyMode
|
||
if addChannelRequest.Channel.Type == constant.ChannelTypeVertexAi && addChannelRequest.Channel.GetOtherSettings().VertexKeyType != dto.VertexKeyTypeAPIKey {
|
||
array, err := getVertexArrayKeys(addChannelRequest.Channel.Key)
|
||
if err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
|
||
return
|
||
}
|
||
addChannelRequest.Channel.ChannelInfo.MultiKeySize = len(array)
|
||
addChannelRequest.Channel.Key = strings.Join(array, "\n")
|
||
} else {
|
||
cleanKeys := make([]string, 0)
|
||
for _, key := range strings.Split(addChannelRequest.Channel.Key, "\n") {
|
||
if key == "" {
|
||
continue
|
||
}
|
||
key = strings.TrimSpace(key)
|
||
cleanKeys = append(cleanKeys, key)
|
||
}
|
||
addChannelRequest.Channel.ChannelInfo.MultiKeySize = len(cleanKeys)
|
||
addChannelRequest.Channel.Key = strings.Join(cleanKeys, "\n")
|
||
}
|
||
keys = []string{addChannelRequest.Channel.Key}
|
||
case "batch":
|
||
if addChannelRequest.Channel.Type == constant.ChannelTypeVertexAi && addChannelRequest.Channel.GetOtherSettings().VertexKeyType != dto.VertexKeyTypeAPIKey {
|
||
array, err := getVertexArrayKeys(addChannelRequest.Channel.Key)
|
||
if err != nil {
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": err.Error()})
|
||
return
|
||
}
|
||
keys = array
|
||
} else {
|
||
keys = strings.Split(addChannelRequest.Channel.Key, "\n")
|
||
}
|
||
case "single":
|
||
keys = []string{addChannelRequest.Channel.Key}
|
||
default:
|
||
c.JSON(http.StatusOK, gin.H{"success": false, "message": "不支持的添加模式"})
|
||
return
|
||
}
|
||
channels := make([]model.Channel, 0, len(keys))
|
||
for _, key := range keys {
|
||
if key == "" {
|
||
continue
|
||
}
|
||
localChannel := addChannelRequest.Channel
|
||
localChannel.Key = key
|
||
localChannel.OwnerUserID = c.GetInt("id")
|
||
localChannel.SupplierApplicationID = supplierApp.ID
|
||
if addChannelRequest.BatchAddSetKeyPrefix2Name && len(keys) > 1 {
|
||
keyPrefix := localChannel.Key
|
||
if len(localChannel.Key) > 8 {
|
||
keyPrefix = localChannel.Key[:8]
|
||
}
|
||
localChannel.Name = fmt.Sprintf("%s %s", localChannel.Name, keyPrefix)
|
||
}
|
||
channels = append(channels, *localChannel)
|
||
}
|
||
if err := model.BatchInsertChannels(channels); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
service.ResetProxyClientCache()
|
||
common.ApiSuccess(c, gin.H{"created": len(channels)})
|
||
}
|
||
|
||
// ListMySupplierChannels godoc
|
||
// @Summary 查询当前供应商渠道列表
|
||
// @Description 供应商返回本人渠道；管理员返回所有供应商渠道
|
||
// @Tags Supplier
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param p query int false "页码"
|
||
// @Param page_size query int false "每页数量"
|
||
// @Param channel_id query int false "渠道ID"
|
||
// @Param name query string false "渠道名称（模糊）"
|
||
// @Param key query string false "渠道密钥（精确或模糊）"
|
||
// @Param base_url query string false "API地址（模糊）"
|
||
// @Param model query string false "模型关键字（模糊）"
|
||
// @Param group query string false "分组"
|
||
// @Success 200 {object} map[string]interface{} "分页结果"
|
||
// @Router /user/supplier/channels [get]
|
||
func ListMySupplierChannels(c *gin.Context) {
|
||
pageInfo := common.GetPageQuery(c)
|
||
channelID, parseErr := model.ParseSupplierChannelIDFilter(c.Query("channel_id"))
|
||
if parseErr != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"success": false, "message": "渠道ID参数格式错误"})
|
||
return
|
||
}
|
||
filter := model.SupplierChannelSearchFilter{
|
||
ChannelID: channelID,
|
||
Name: strings.TrimSpace(c.Query("name")),
|
||
Key: strings.TrimSpace(c.Query("key")),
|
||
BaseURL: strings.TrimSpace(c.Query("base_url")),
|
||
ModelKeyword: strings.TrimSpace(c.Query("model")),
|
||
Group: strings.TrimSpace(c.Query("group")),
|
||
}
|
||
var (
|
||
items []*model.Channel
|
||
total int64
|
||
err error
|
||
)
|
||
if c.GetInt("role") >= common.RoleAdminUser {
|
||
items, total, err = model.SearchSupplierChannels(nil, pageInfo.GetStartIdx(), pageInfo.GetPageSize(), filter)
|
||
} else {
|
||
ownerUserID := c.GetInt("id")
|
||
items, total, err = model.SearchSupplierChannels(&ownerUserID, pageInfo.GetStartIdx(), pageInfo.GetPageSize(), filter)
|
||
}
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
for _, item := range items {
|
||
clearChannelInfo(item)
|
||
}
|
||
common.ApiSuccess(c, gin.H{
|
||
"items": items,
|
||
"total": total,
|
||
"page": pageInfo.GetPage(),
|
||
"page_size": pageInfo.GetPageSize(),
|
||
})
|
||
}
|
||
|
||
// CreateMySupplierModel godoc
|
||
// @Summary 当前供应商新增模型
|
||
// @Description 仅审核通过供应商可新增，自动写入 owner_user_id 与 supplier_application_id
|
||
// @Tags Supplier
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Security CookieAuth
|
||
// @Security ApiUserID
|
||
// @Param request body model.Model true "模型创建参数"
|
||
// @Success 200 {object} map[string]interface{} "创建结果"
|
||
// @Router /user/supplier/models [post]
|
||
func CreateMySupplierModel(c *gin.Context) {
|
||
supplierApp, ok := requireApprovedSupplierApplication(c)
|
||
if !ok {
|
||
return
|
||
}
|
||
var m model.Model
|
||
if err := c.ShouldBindJSON(&m); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if m.ModelName == "" {
|
||
common.ApiErrorMsg(c, "模型名称不能为空")
|
||
return
|
||
}
|
||
dup, err := model.IsModelNameDuplicated(0, m.ModelName)
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
if dup {
|
||
common.ApiErrorMsg(c, "模型名称已存在")
|
||
return
|
||
}
|
||
m.OwnerUserID = c.GetInt("id")
|
||
m.SupplierApplicationID = supplierApp.ID
|
||
if err := m.Insert(); err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
model.RefreshPricing()
|
||
common.ApiSuccess(c, &m)
|
||
}
|
||
|
||
// ListMySupplierModels godoc
|
||
// @Summary 查询当前供应商模型列表
|
||
// @Description 仅返回当前登录供应商创建的模型
|
||
// @Tags Supplier
|
||
// @Produce json
|
||
// @Security ApiKeyAuth
|
||
// @Security ApiUserID
|
||
// @Param p query int false "页码"
|
||
// @Param page_size query int false "每页数量"
|
||
// @Param model_name query string false "模型名称（模糊）"
|
||
// @Param model_type query string false "模型类型（映射 vendor，支持名称或ID）"
|
||
// @Success 200 {object} map[string]interface{} "分页结果"
|
||
// @Router /user/supplier/models [get]
|
||
func ListMySupplierModels(c *gin.Context) {
|
||
pageInfo := common.GetPageQuery(c)
|
||
keyword := strings.TrimSpace(c.Query("model_name"))
|
||
vendor := strings.TrimSpace(c.Query("model_type"))
|
||
var (
|
||
items []*model.Model
|
||
total int64
|
||
err error
|
||
)
|
||
if c.GetInt("role") >= common.RoleAdminUser {
|
||
items, total, err = model.SearchSupplierModels(nil, keyword, vendor, pageInfo.GetStartIdx(), pageInfo.GetPageSize())
|
||
} else {
|
||
ownerUserID := c.GetInt("id")
|
||
items, total, err = model.SearchSupplierModels(&ownerUserID, keyword, vendor, pageInfo.GetStartIdx(), pageInfo.GetPageSize())
|
||
}
|
||
if err != nil {
|
||
common.ApiError(c, err)
|
||
return
|
||
}
|
||
enrichModels(items)
|
||
common.ApiSuccess(c, gin.H{
|
||
"items": items,
|
||
"total": total,
|
||
"page": pageInfo.GetPage(),
|
||
"page_size": pageInfo.GetPageSize(),
|
||
})
|
||
}
|