rbac

type AuthDTO struct {
	BaseDTO

	Mechanism string      `json:"mechanism"`
	Account   string      `json:"account"`
	Secret    lang.Base64 `json:"secret"`

	User        *UserDTO    `json:"user"`         // 用户信息 (optional)
	Step        int         `json:"step"`         // 表示验证的步骤
	NewPassword lang.Base64 `json:"new_password"` // 新的密码（用于注册，设置，重设密码）
	Success     bool        `json:"success"`      // 是否完成并且成功

	Properties map[string]string `json:"properties"` // 其它扩展属性
}

type AuthService interface {
	Login(c context.Context, a *AuthDTO) (*AuthDTO, error)
}

type AuthVO struct {
	BaseVO

	Auth AuthDTO `json:"auth"` // 用于验证的信息
}

type BaseDTO struct {
	UUID lang.UUID `json:"uuid"`

	CreatedAt lang.Time `json:"created_at"`
	UpdatedAt lang.Time `json:"updated_at"`
	DeletedAt lang.Time `json:"deleted_at"`

	Owner   UserID `json:"owner"`
	Creator UserID `json:"creator"`
	Updater UserID `json:"updater"`
}

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

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

	Owner   UserID
	Creator UserID
	Updater UserID
}

type BaseVO struct {
	Status     int         `json:"status"`
	Message    string      `json:"message"`
	Error      string      `json:"error"`
	Time       time.Time   `json:"time"`
	Timestamp  lang.Time   `json:"timestamp"`
	Pagination *Pagination `json:"pagination"`
}

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

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

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

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

type EmailAddressDTO struct {
	ID EmailAddressID `json:"id"`

	BaseDTO

	Address string `json:"address"`
}

type EmailAddressEntity struct {
	ID EmailAddressID

	BaseEntity

	Address string `gorm:"unique"`
}

type EmailAddressID int64

type EmailAddressQuery struct {
	Pagination Pagination
}

type EmailAddressService interface {
	Insert(c context.Context, o *EmailAddressDTO) (*EmailAddressDTO, error)
	Update(c context.Context, id EmailAddressID, o *EmailAddressDTO) (*EmailAddressDTO, error)
	Delete(c context.Context, id EmailAddressID) error

	Find(c context.Context, id EmailAddressID) (*EmailAddressDTO, error)
	List(c context.Context, q *EmailAddressQuery) ([]*EmailAddressDTO, error)
}

type Pagination struct {
	Page  int64 `json:"page"`  // 页码, first=1
	Size  int   `json:"size"`  // 页大小
	Total int64 `json:"total"` // 所有页面的条目总数
}

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

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

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

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

type PermissionDTO struct {
	ID PermissionID `json:"id"`

	BaseDTO

	Method      string       `json:"method"`
	Path        string       `json:"path"`
	AcceptRoles RoleNameList `json:"accept_roles"`
}

type PermissionEntity struct {
	ID PermissionID

	BaseEntity

	Method      string
	Path        string
	Resource    string `gorm:"unique"` // like 'method + ":" + path'
	AcceptRoles RoleNameList
}

type PermissionID int64

type PermissionQuery struct {
	Pagination Pagination
}

type PermissionService interface {
	Insert(c context.Context, o *PermissionDTO) (*PermissionDTO, error)
	Update(c context.Context, id PermissionID, o *PermissionDTO) (*PermissionDTO, error)
	Delete(c context.Context, id PermissionID) error

	Find(c context.Context, id PermissionID) (*PermissionDTO, error)
	List(c context.Context, q *PermissionQuery) ([]*PermissionDTO, error)
}

type PermissionVO struct {
	BaseVO

	Permissions []*PermissionDTO `json:"permissions"`
}

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

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

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

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

type PhoneNumberDTO struct {
	ID PhoneNumberID `json:"id"`

	BaseDTO

	SimpleNunber string `json:"simple_number"`
}

type PhoneNumberEntity struct {
	ID PhoneNumberID

	BaseDTO

	SimpleNunber string `gorm:"unique"`
}

type PhoneNumberID int64

type PhoneNumberQuery struct {
	Pagination Pagination
}

type PhoneNumberService interface {
	Insert(c context.Context, o *PhoneNumberDTO) (*PhoneNumberDTO, error)
	Update(c context.Context, id PhoneNumberID, o *PhoneNumberDTO) (*PhoneNumberDTO, error)
	Delete(c context.Context, id PhoneNumberID) error

	Find(c context.Context, id PhoneNumberID) (*PhoneNumberDTO, error)
	List(c context.Context, q *PhoneNumberQuery) ([]*PhoneNumberDTO, error)
}

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

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

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

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

type RoleDTO struct {
	ID RoleID `json:"id"`

	BaseDTO

	Name RoleName `json:"name"`
}

type RoleEntity struct {
	ID RoleID

	BaseEntity

	Name RoleName `gorm:"unique"`
}

type RoleID int64

type RoleName string

type RoleNameList string

type RoleQuery struct {
	Pagination Pagination
}

type RoleService interface {
	Insert(c context.Context, o *RoleDTO) (*RoleDTO, error)
	Update(c context.Context, id RoleID, o *RoleDTO) (*RoleDTO, error)
	Delete(c context.Context, id RoleID) error

	Find(c context.Context, id RoleID) (*RoleDTO, error)
	List(c context.Context, q *RoleQuery) ([]*RoleDTO, error)
}

type RoleVO struct {
	BaseVO

	Roles []*RoleDTO `json:"roles"`
}

type SessionDTO struct {
	BaseDTO

	ExpiredAt  lang.Time `json:"expired_at"` // 会话的过期时间
	User       UserDTO   `json:"user"`       // 用户信息
	Authorized bool      `json:"authorized"` // 是否已授权

	Properties map[string]string `json:"properties"`
}

type SessionService interface {
	GetCurrent(c context.Context) (*SessionDTO, error)
}

type SessionVO struct {
	BaseVO

	Sessions []*SessionDTO `json:"sessions"`
}

type TableGroup struct {
}

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

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

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

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

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

type UserDTO struct {
	ID UserID `json:"id"`

	BaseDTO

	Name     UserName     `json:"name"`
	NickName string       `json:"nickname"`
	Avatar   string       `json:"avatar"`
	Phone    string       `json:"phone"`
	Email    string       `json:"email"`
	Roles    RoleNameList `json:"roles"`
}

type UserEntity struct {
	ID UserID

	BaseEntity

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

	Nickname string       // 昵称
	Avatar   string       // 头像 (HTTP-URL)
	Phone    string       // 主要的手机号
	Email    string       // 主要的 e-mail 地址
	Roles    RoleNameList // 用户的角色

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

type UserID int64

type UserName string

type UserQuery struct {
	Pagination Pagination
}

type UserService interface {
	Insert(c context.Context, o *UserDTO) (*UserDTO, error)
	Update(c context.Context, id UserID, o *UserDTO) (*UserDTO, error)
	Delete(c context.Context, id UserID) error

	Find(c context.Context, id UserID) (*UserDTO, error)
	List(c context.Context, q *UserQuery) ([]*UserDTO, error)
}

type UserVO struct {
	BaseVO

	Users []*UserDTO `json:"users"`
}

type VOGetter interface {
	GetVO() *BaseVO
}