data

type BaseEntity struct {
	UUID lang.UUID `gorm:"unique"`

	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `gorm:"index"`

	Group   rbac.GroupID
	Owner   rbac.UserID
	Creator rbac.UserID
	Updater rbac.UserID
}

type EmailAddressConvertor interface {
	ConvertE2D(c context.Context, entity *EmailAddressEntity) (*rbac.EmailAddressDTO, error)
	ConvertD2E(c context.Context, dto *rbac.EmailAddressDTO) (*EmailAddressEntity, error)

	ConvertListE2D(c context.Context, entity []*EmailAddressEntity) ([]*rbac.EmailAddressDTO, error)
}

type EmailAddressDAO interface {
	Insert(db *gorm.DB, o *EmailAddressEntity) (*EmailAddressEntity, error)
	Update(db *gorm.DB, id rbac.EmailAddressID, updater func(*EmailAddressEntity)) (*EmailAddressEntity, error)
	Delete(db *gorm.DB, id rbac.EmailAddressID) error

	Find(db *gorm.DB, id rbac.EmailAddressID) (*EmailAddressEntity, error)
	List(db *gorm.DB, q *rbac.EmailAddressQuery) ([]*EmailAddressEntity, error)

	FindByAddress(db *gorm.DB, address rbac.EmailAddress) (*EmailAddressEntity, error)
}

type EmailAddressEntity struct {
	ID rbac.EmailAddressID `gorm:"primaryKey"`

	BaseEntity

	Address  rbac.EmailAddress `gorm:"unique"`
	Verified bool
}

type Entity struct {
	BaseEntity
}

type Finder interface {
	Init(db *gorm.DB) Finder
	AsList(list any) Finder
	AsEntity(entity any) Finder
	All(all bool) Finder
	WithPagination(page *rbac.Pagination) Finder
	WithConditions(cond *rbac.Conditions) Finder
	Find() error
}

type GroupConvertor interface {
	ConvertE2D(c context.Context, entity *GroupEntity) (*rbac.GroupDTO, error)
	ConvertD2E(c context.Context, dto *rbac.GroupDTO) (*GroupEntity, error)

	ConvertListE2D(c context.Context, entity []*GroupEntity) ([]*rbac.GroupDTO, error)
}

type GroupDAO interface {
	Insert(db *gorm.DB, o *GroupEntity) (*GroupEntity, error)
	Update(db *gorm.DB, id rbac.GroupID, updater func(o *GroupEntity)) (*GroupEntity, error)
	Delete(db *gorm.DB, id rbac.GroupID) error

	Find(db *gorm.DB, id rbac.GroupID) (*GroupEntity, error)
	List(db *gorm.DB, q *rbac.GroupQuery) ([]*GroupEntity, error)
}

type GroupEntity struct {
	ID rbac.GroupID `gorm:"primaryKey"`

	BaseEntity

	Name rbac.GroupName `gorm:"unique"` // 用户分组名称

	Label       string            // 昵称
	Description string            // 头像 (HTTP-URL)
	Roles       rbac.RoleNameList // 用户的角色
	Enabled     bool              // 启用该项
}

type PermissionConvertor interface {
	ConvertE2D(c context.Context, entity *PermissionEntity) (*rbac.PermissionDTO, error)
	ConvertD2E(c context.Context, dto *rbac.PermissionDTO) (*PermissionEntity, error)

	ConvertListE2D(c context.Context, entity []*PermissionEntity) ([]*rbac.PermissionDTO, error)
}

type PermissionDAO interface {
	Insert(db *gorm.DB, o *PermissionEntity) (*PermissionEntity, error)
	Update(db *gorm.DB, id rbac.PermissionID, updater func(*PermissionEntity)) (*PermissionEntity, error)
	Delete(db *gorm.DB, id rbac.PermissionID) error

	Find(db *gorm.DB, id rbac.PermissionID) (*PermissionEntity, error)
	List(db *gorm.DB, q *rbac.PermissionQuery) ([]*PermissionEntity, error)
	ListAll(db *gorm.DB) ([]*PermissionEntity, error)
}

type PermissionEntity struct {
	ID rbac.PermissionID `gorm:"primaryKey"`

	BaseEntity

	Method      string
	Path        string
	Resource    string            `gorm:"unique"` // like 'method + ":" + path'
	AcceptRoles rbac.RoleNameList `gorm:"column:roles"`
	Enabled     bool              // 启用该项

}

type PhoneNumberConvertor interface {
	ConvertE2D(c context.Context, entity *PhoneNumberEntity) (*rbac.PhoneNumberDTO, error)
	ConvertD2E(c context.Context, dto *rbac.PhoneNumberDTO) (*PhoneNumberEntity, error)

	ConvertListE2D(c context.Context, entity []*PhoneNumberEntity) ([]*rbac.PhoneNumberDTO, error)
}

type PhoneNumberDAO interface {
	Insert(db *gorm.DB, o *PhoneNumberEntity) (*PhoneNumberEntity, error)
	Update(db *gorm.DB, id rbac.PhoneNumberID, updater func(*PhoneNumberEntity)) (*PhoneNumberEntity, error)
	Delete(db *gorm.DB, id rbac.PhoneNumberID) error

	Find(db *gorm.DB, id rbac.PhoneNumberID) (*PhoneNumberEntity, error)
	FindByNumber(db *gorm.DB, num rbac.FullPhoneNumber) (*PhoneNumberEntity, error)
	List(db *gorm.DB, q *rbac.PhoneNumberQuery) ([]*PhoneNumberEntity, error)
}

type PhoneNumberEntity struct {
	ID rbac.PhoneNumberID `gorm:"primaryKey"`

	BaseEntity

	FullNumber rbac.PurePhoneNumber `gorm:"unique"`

	Region       rbac.RegionPhoneCode
	SimpleNumber rbac.SimplePhoneNumber
	Verified     bool
}

type RegionConvertor interface {
	ConvertE2D(c context.Context, entity *RegionEntity) (*rbac.RegionDTO, error)
	ConvertD2E(c context.Context, dto *rbac.RegionDTO) (*RegionEntity, error)

	ConvertListE2D(c context.Context, entity []*RegionEntity) ([]*rbac.RegionDTO, error)
}

type RegionDAO interface {
	Insert(db *gorm.DB, o *RegionEntity) (*RegionEntity, error)
	Update(db *gorm.DB, id rbac.RegionID, updater func(*RegionEntity)) (*RegionEntity, error)
	Delete(db *gorm.DB, id rbac.RegionID) error

	Find(db *gorm.DB, id rbac.RegionID) (*RegionEntity, error)
	List(db *gorm.DB, q *rbac.RegionQuery) ([]*RegionEntity, error)
	ListAll(db *gorm.DB) ([]*RegionEntity, error)
}

type RegionEntity struct {
	ID rbac.RegionID

	BaseEntity

	DisplayName string
	SimpleName  string
	FullName    string
	FlagURL     string
	Code2       rbac.RegionCode2     `gorm:"unique"`
	Code3       rbac.RegionCode3     `gorm:"unique"`
	PhoneCode   rbac.RegionPhoneCode `gorm:"unique"`
}

type RoleConvertor interface {
	ConvertE2D(c context.Context, entity *RoleEntity) (*rbac.RoleDTO, error)
	ConvertD2E(c context.Context, dto *rbac.RoleDTO) (*RoleEntity, error)

	ConvertListE2D(c context.Context, entity []*RoleEntity) ([]*rbac.RoleDTO, error)
}

type RoleDAO interface {
	Insert(db *gorm.DB, o *RoleEntity) (*RoleEntity, error)
	Update(db *gorm.DB, id rbac.RoleID, updater func(*RoleEntity)) (*RoleEntity, error)
	Delete(db *gorm.DB, id rbac.RoleID) error

	Find(db *gorm.DB, id rbac.RoleID) (*RoleEntity, error)
	List(db *gorm.DB, q *rbac.RoleQuery) ([]*RoleEntity, error)
	ListAll(db *gorm.DB) ([]*RoleEntity, error)
}

type RoleEntity struct {
	ID rbac.RoleID `gorm:"primaryKey"`

	BaseEntity

	Name        rbac.RoleName `gorm:"unique"`
	Description string
}

type UserConvertor interface {
	ConvertE2D(c context.Context, entity *UserEntity) (*rbac.UserDTO, error)
	ConvertD2E(c context.Context, dto *rbac.UserDTO) (*UserEntity, error)

	ConvertListE2D(c context.Context, entity []*UserEntity) ([]*rbac.UserDTO, error)
}

type UserDAO interface {
	Insert(db *gorm.DB, o *UserEntity) (*UserEntity, error)
	Update(db *gorm.DB, id rbac.UserID, updater func(o *UserEntity)) (*UserEntity, error)
	Delete(db *gorm.DB, id rbac.UserID) error

	FindByAny(db *gorm.DB, text string) (*UserEntity, error)
	FindByName(db *gorm.DB, name rbac.UserName) (*UserEntity, error)
	FindByPhone(db *gorm.DB, phone rbac.FullPhoneNumber) (*UserEntity, error)
	FindByEmail(db *gorm.DB, email rbac.EmailAddress) (*UserEntity, error)

	Find(db *gorm.DB, id rbac.UserID) (*UserEntity, error)
	List(db *gorm.DB, q *rbac.UserQuery) ([]*UserEntity, error)
}

type UserEntity struct {
	ID rbac.UserID `gorm:"primaryKey"`

	BaseEntity

	Name rbac.UserName `gorm:"unique"` // 用户名

	Nickname string              // 昵称
	Avatar   string              // 头像 (HTTP-URL)
	Language string              // i18n 语言
	Phone    rbac.PhoneNumberID  // 主要的手机号
	Email    rbac.EmailAddressID // 主要的 e-mail 地址
	Roles    rbac.RoleNameList   // 用户的角色
	Enabled  bool                // 启用该项

	Password lang.Hex // 用户当前的密码
	Salt     lang.Hex // 跟密码相关的盐
}