json - 使用 gorm 创建记录时如何验证所属关系

Question

我有以下型号

type PrivateGormModel struct {
    ID        uint       `gorm:"primary_key" json:"id"`
    CreatedAt time.Time  `json:"-"`
    UpdatedAt time.Time  `json:"-"`
    DeletedAt *time.Time `json:"-"`
}

type Employee struct {
    PrivateGormModel
    Person          `gorm:"embedded" json:"person,omitempty"`
    Contact         `gorm:"embedded" json:"contact,omitempty"`
    Address         `gorm:"embedded" json:"address,omitempty"`
    AltContact      `gorm:"embedded" json:"privateContact,omitempty"`
    BankAccount     `gorm:"embedded" json:"bankAccount,omitempty"`
    EmployeeGroupID uint `json:"groupID"`
    EmployeeGroup   `json:"group"`
    EmployeeRoleID  uint `json:"roleID"`
    EmployeeRole    `json:"role"`
}

func (e Employee) Validate() error {
    return validation.ValidateStruct(&e,
        validation.Field(&e.Person, validation.Required),
        validation.Field(&e.Contact),
        validation.Field(&e.Address),
        validation.Field(&e.AltContact),
        validation.Field(&e.BankAccount),
        validation.Field(&e.EmployeeGroup),
        validation.Field(&e.EmployeeRole),
    )
}

type EmployeeGroup struct {
    PrivateGormModel
    Title string `json:"title" gorm:"primaryKey;unique"`
}

func (e EmployeeGroup) Validate() error {
    return validation.ValidateStruct(&e,
        validation.Field(&e.Title, validation.Required, validation.Length(1, 32), validation.Match(regexp.MustCompile(`^[a-zA-Z0-9_ ]*$`))),
    )
}

type EmployeeRole struct {
    PrivateGormModel
    Title string `json:"title" gorm:"primaryKey;unique"`
}

func (e EmployeeRole) Validate() error {
    return validation.ValidateStruct(&e,
        validation.Field(&e.Title, validation.Required, validation.Length(1, 32), validation.Match(regexp.MustCompile(`^[a-zA-Z0-9_ ]*$`))),
    )
}

我的员工组和员工角色都只是一个带有 gorm 模型和字符串类型的标题的结构。我在数据库中有一个 ID 为 1 的角色，一个 ID 为 1 的组。这是创建员工的处理程序

func CreateEmployee(db *database.Database) fiber.Handler {
    return func(c *fiber.Ctx) error {
        employee := new(model.Employee)

        if err := c.BodyParser(employee); err != nil {
            fmt.Printf("%v", err)
            return c.JSON(myResponse.ParsingError())
        }

        // if err := employee.Validate(); err != nil {
        //  return c.JSON(myResponse.ValidationError(err))
        // }

        if result := db.Omit("EmployeeRole.*").Omit("EmployeeGroup.*").Create(&employee); result.Error != nil {
            return c.JSON(myResponse.RecordCreateError())
        }

        return c.JSON(myResponse.RecordCreateSuccess(employee))
    }
}

我将传入的 JSON 解析为如下所示的模型，然后尝试在数据库中创建它

{
    "Person":{
        "Initials":"",
        "FirstName":"",
        "MiddleName":"",
        "LastName":"",
        "DateOfBirth":"",
        "Language":""
    },
    "Address":{
        "Country":"",
        "Zip":"",
        "Number":"0",
        "Addition":"",
        "Street":"",
        "State":"",
        "City":""
    },
    "Contact":{
        "Tel":"",
        "Mail":"",
        "URL":""
    },
    "BankAccount":{
        "Bank":"",
        "BIC":"",
        "IBAN":"",
        "AccountHolder":"",
        "Establishment":""
    },
    "EmployeeRoleID":1,
    "EmployeeRole":{
        "Title":"Test"
    },
    "EmployeeGroupID":1,
    "EmployeeGroup":{
        "Title":"Test"
    }
}

这给了我以下回应

{
    "data": {
        "id": 7,
        "person": {
            "initials": "",
            "firstName": "",
            "middleName": "",
            "lastName": "",
            "dateOfBirth": "2021-01-05T11:14:38+01:00",
            "language": ""
        },
        "contact": {
            "tel": "",
            "mail": "",
            "url": ""
        },
        "address": {
            "country": "",
            "zip": "",
            "number": "0",
            "addition": "",
            "street": "",
            "state": "",
            "city": ""
        },
        "privateContact": {
            "tel": "",
            "mail": "",
            "url": ""
        },
        "bankAccount": {
            "bank": "",
            "bic": "",
            "iban": "",
            "accountHolder": "",
            "establishment": ""
        },
        "groupID": 0,
        "group": {
            "id": 0,
            "title": ""
        },
        "roleID": 0,
        "role": {
            "id": 0,
            "title": ""
        }
    },
    "message": "record created successfully",
    "status": "success"
}

即使 ID 为 1 的角色记录和 ID 为 1 的组记录不存在，这也会给我以下响应。如果角色或组不存在，它应该给我一个错误而不是创建记录。

Answer 1

您如何建立关系并不明显，因为您似乎正在为 EmployeeGroup 和 EmployeeRole 使用匿名嵌入式结构，并且您没有包含这些代码。我将假设您已正确设置，并且 gorm 很乐意处理涉及匿名嵌入结构的关系。
我还将假设您的意思是 BelongsTo 关系，否则您会将外键放在哪里以将 Employee 表与 Role 或 Group 表相链接？很明显，外键不在最后两个中。
因此，您已经获得了一个 Employee 结构，当给出无效的 GroupID 或 RoleID 时，您有两个选择:要么在 ID 不存在时拒绝该操作，要么使用给定的 ID 创建一个新的角色/组。第一个是更理智和更常用的处理方式，但 gorm 可以做任何一个。
首先，如果您的数据库中有外键检查，您可以执行以下操作:

// First make sure that EmployeeRoleID and EmployeeGroupID are set 
err := db.Omit("EmployeeRole", "EmployeeGroup").Create(employee).Error

如果 EmployeeGroup.ID 或 EmployeeRole.ID 不存在，则会发生外键冲突，您将收到错误消息。您可以检查错误并推断它与外键有关，然后返回适当的 API 级别错误。
根据您使用的数据库，您可能会发现此错误检查有点麻烦。老实说，在保存实体之前触发一堆额外的关系验证查询是非常常见的，所以不要对在这种情况下必须这样做感到惊讶。
另一方面，如果你想每次都保存一个新的角色和组，你可以去掉 Omit 调用，确保每个 ID 为零，然后调用 Create。 Gorm 将保存角色和组，为他们提供新的 ID，然后将这些新 ID 的链接保存在员工记录中。

编辑
我试着运行你的代码，发现了一些问题:

首先，您的输入 JSON 具有所有 TitleCased 键名，但模型结构期望它们中的很多是小写的。您需要决定一个或另一个并坚持下去，否则编码和解码将不起作用。

同样适用于 EmployeeRoleID/EmployeeGroupID对比 groupID/roleID .在 JSON 中有一个版本的名称，在 Go 结构中有一个版本(如果您删除了 json:"blah" 标签，它们也可以是相同的 TitleCased 版本)。

Gorm 不喜欢为相关实体嵌入匿名结构，它不会为它们创建外键并在主表中创建无关的字段，不要这样做。

您已将 Role 和 Group 的名称用作复合主键的一部分，但这会破坏键控，因为您需要主结构中的两个字段才能使其工作，例如EmployeeGroupID和 EmployeeGroupName ，这违背了拥有单独实体的目的。如果要在名称中强制执行唯一性，请改为添加唯一索引。

原来是 Omit("Relation.*")仅适用于多对多关系。对于属于的事情要做的是填写RelationID主结构中的字段，并通常省略与 Omit("Relation") 的关系.

这是您的模型的简化版本:

type Employee struct {
    PrivateGormModel
    Person  `gorm:"embedded" json:"Person"`
    // ...
    RoleID  uint
    Role    EmployeeRole `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type EmployeeRole struct {
    PrivateGormModel
    Title string `gorm:"uniqueIndex"`
}

这是一个测试用例，展示了它是如何工作的，假设有一个配置的 DB *gorm.DB :

package main

import (
    "encoding/json"
    "testing"

    "github.com/stretchr/testify/require"
)

var inJSON = `{
    "Person": {
        "FirstName": "Test"
    },
    "RoleID": 1
}`

func TestGORM(t *testing.T) {
    require := require.New(t)
    require.NoError(DB.Migrator().DropTable(&Employee{}, &EmployeeRole{}))
    require.NoError(DB.Migrator().AutoMigrate(&Employee{}, &EmployeeRole{}))
    emp := Employee{}
    json.Unmarshal([]byte(inJSON), &emp)

    // create the role to simulate that it exists
    role := EmployeeRole{PrivateGormModel{ID: 1}, "Test"}
    require.NoError(DB.Create(&role).Error)

    // avoid re-saving emp.Role
    require.NoError(DB.Omit("Role").Create(&emp).Error)

    // if instead the RoleID doesn't exist
    emp.RoleID = 5
    require.Error(DB.Create(&emp).Error)
}