如何在使用gorm创建记录时验证归属关系

我有以下型号的

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组记录不存在，它也会给我以下响应。如果角色或组不存在，它应该给我一个错误，而不是创建记录。

您是如何建立关系的并不明显，因为您似乎对EmployeeGroup和EmployeeRole都使用了匿名嵌入结构，而且还没有包含这些结构的代码。我假设你已经正确地设置了这一点，gorm很乐意处理涉及匿名嵌入结构的关系。

我还假设你指的是BelongsTo关系，否则你会把外键放在哪里，把Employee表与Role表或Group表链接起来？很明显，外键不在后两个中的任何一个中。

因此，您得到了一个Employee结构，当给定一个无效的GroupID或RoleID时，您有两个选项：当ID不存在时拒绝操作，或者使用给定的ID创建一个新的Role/Group。第一种是更理智和常见的处理方式，但戈尔姆可以做任何一种。

首先，如果您的数据库中有外键检查，您可以执行以下操作：

// 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.*")只适用于多对多关系。For属于要做的事情是填充主结构中的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)
}

编辑

相关内容

最新更新

热门标签：