dao

package
v0.0.0-...-ae394c8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 30, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ApplicationRecord 

type ApplicationRecord interface {
	Create(*entity.ApplicationRecord) (*entity.ApplicationRecord, error)
	Delete(*entity.ApplicationRecord) error
	Select(en *entity.ApplicationRecord, pg *Pagination, st, et *time.Time) ([]*entity.ApplicationRecord, error)
	CountDetail(en *model.ApplicationRecordModel, st, et *time.Time) (int32, error)
	Count(en *entity.ApplicationRecord, st, et *time.Time) (int32, error)
	Update(*entity.ApplicationRecord) (*entity.ApplicationRecord, error)
	FindByPk(en *entity.ApplicationRecord) (*entity.ApplicationRecord, error)
	UpdateByUserEntryPk(en *entity.ApplicationRecord) (*entity.ApplicationRecord, error)
	Find(en *entity.ApplicationRecord) (*entity.ApplicationRecord, error)
	SelectWithDetail(en *model.ApplicationRecordModel, pg *Pagination, st, et *time.Time) ([]*model.ApplicationRecordModel, error)
}

func NewApplicationRecord 

func NewApplicationRecord(db *gorm.DB, rs *helper.Redis) ApplicationRecord

type Car 

type Car interface {
	Select(*entity.Car, *entity.Pagination) ([]*entity.Car, error)
	Count(en *entity.Car) (int32, error)
}

func NewCar 

func NewCar(db *gorm.DB) Car

type CarApply 

type CarApply interface {
}

func NewCarApply 

func NewCarApply(db *gorm.DB) CarApply

type Dao 

type Dao interface {
	Permission() Permission
	PermissionGroup() PermissionGroup
	UserPermission() UserPermission
	PermissionGroupPermission() PermissionGroupPermission
	Role() Role
	RoleGroup() RoleGroup
	RoleGroupPermission() RoleGroupPermission
	RolePermission() RolePermission
	User() User
	UserClient() UserClient
	Enterprise() Enterprise
	UserRealNameAuthenticationLog() UserRealNameAuthenticationLog
	Files() Files
	UserProfession() UserProfession
	UserCredentials() UserCredentials
	InterfaceResource() InterfaceResource
	PageResource() PageResource
	PageInterface() PageInterface
	MenuResource() MenuResource
	Redis() *helper.Redis
	Sms() Sms
	Department() Department
	Project() Project
	ProjectEnterpriseRelation() ProjectEnterpriseRelation
	ProjectMember() ProjectMember
	ProjectPost() ProjectPost
	Position() Position
	ApplicationRecord() ApplicationRecord
	Member() Member
	UserEntry() UserEntry
	EnterpriseUser() EnterpriseUser
	EnterpriseAreaPermission() EnterpriseAreaPermission
	EnterpriseUserAttachment() EnterpriseUserAttachment
	TurnoverRecord() TurnoverRecord
	EnterpriseRelation() EnterpriseRelation
	LogisticsPurchase() LogisticsPurchase
	TemporaryWorker() TemporaryWorker
	LogisticsWarehousing() LogisticsWarehousing
	LogisticsInventory() LogisticsInventory
	LogisticsDelivery() LogisticsDelivery
	WorkSchedule() WorkSchedule
	WorkSchedulePost() WorkSchedulePost
	PatrolRoute() PatrolRoute
	PatrolPoint() PatrolPoint
	PatrolRoutePoint() PatrolRoutePoint
	PatrolRouteRecord() PatrolRouteRecord
	PatrolRouteRecordPoint() PatrolRouteRecordPoint
	InspectionPlan() InspectionPlan
	InspectionPlanPoint() InspectionPlanPoint
	InspectionPlanUser() InspectionPlanUser
	InspectionPoint() InspectionPoint
	Car() Car
	CarApply() CarApply
}

Dao 定义接口规范

func NewDao 

func NewDao(db *gorm.DB, rs *helper.Redis) Dao

NewDao 实例化接口规范实现类

type Department 

type Department interface {
	Create(*entity.Department) (*entity.Department, error)
	Delete(*entity.Department) error
	Select(*entity.Department, *Pagination) ([]*entity.Department, error)
	Count(*entity.Department) (int32, error)
	Update(*entity.Department) (*entity.Department, error)
	FindByPk(en *entity.Department) (*entity.Department, error)
	SelectAllDepartmentList(en *entity.DepartmentList) ([]*entity.DepartmentList, error)
	FindByEnterprisePkAndName(en *entity.Department) (*entity.Department, error)
}

func NewDepartment 

func NewDepartment(db *gorm.DB, rs *helper.Redis) Department

type Enterprise 

type Enterprise interface {
	Create(*entity.Enterprise) (*model.Enterprise, error)
	Delete(*entity.Enterprise) error
	Select(*entity.Enterprise, *Pagination) ([]*model.Enterprise, error)
	Count(*entity.Enterprise) (int32, error)
	Update(*entity.Enterprise) (*model.Enterprise, error)
	FindByPk(en *entity.Enterprise) (*model.Enterprise, error)
	FindEnterpriseByUserPk(en *model.EnterpriseModel) ([]*entity.Enterprise, error)
	SelectEnterpriseForEnterpriseAreaPermission(list []*entity.EnterpriseAreaPermission, en *entity.Enterprise, pg *entity.Pagination) ([]*model.Enterprise, error)
	CountEnterpriseForEnterpriseAreaPermission(list []*entity.EnterpriseAreaPermission, en *entity.Enterprise) (int32, error)
}

func NewEnterprise 

func NewEnterprise(db *gorm.DB, rs *helper.Redis) Enterprise

type EnterpriseAreaPermission 

type EnterpriseAreaPermission interface {
	Create(areaPermission *entity.EnterpriseAreaPermission) (*entity.EnterpriseAreaPermission, error)
	CheckRepetition(areaPermission *entity.EnterpriseAreaPermission) (bool, error)
	Delete(uu *entity.EnterpriseAreaPermission) error
	Select(uu *entity.EnterpriseAreaPermission, page *entity.Pagination) ([]*entity.EnterpriseAreaPermission, error)
	Count(uu *entity.EnterpriseAreaPermission) (int32, error)
	FindList(areaPermission *entity.EnterpriseAreaPermission) ([]*entity.EnterpriseAreaPermission, error)
}

func NewEnterpriseAreaPermission 

func NewEnterpriseAreaPermission(db *gorm.DB) EnterpriseAreaPermission

type EnterpriseRelation 

type EnterpriseRelation interface {
	Create(*entity.EnterpriseRelation) (*entity.EnterpriseRelation, error)
	Delete(*entity.EnterpriseRelation) error
	Select(*entity.EnterpriseRelation, *Pagination) ([]*entity.EnterpriseRelation, error)
	Count(*entity.EnterpriseRelation) (int32, error)
	Update(*entity.EnterpriseRelation) (*entity.EnterpriseRelation, error)
	FindByPk(en *entity.EnterpriseRelation) (*entity.EnterpriseRelation, error)
	DeleteByRelationEnterprisePkAndProjectPk(uu *entity.EnterpriseRelation) error
	SelectCustomerEnterprise(en *model.EnterpriseRelationQuery, pg *Pagination) ([]*model.Enterprise, int32, error)
	SelectCustomerRelationProject(en *model.EnterpriseRelationProjectQuery, pg *Pagination) ([]*model.Project, int32, error)
}

func NewEnterpriseRelation 

func NewEnterpriseRelation(db *gorm.DB) EnterpriseRelation

type EnterpriseUser 

type EnterpriseUser interface {
	Create(*entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	CreateEnterpriseUserAndUser(en *entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	//CreateOrSelectEnterpriseUserAndUser(en *entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	Delete(*entity.EnterpriseUser) error
	Select(*entity.EnterpriseUser, *Pagination) ([]*entity.EnterpriseUser, error)
	Count(*entity.EnterpriseUser) (int32, error)
	Update(*entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	FindByPk(en *entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	FindByUserPkAndEnterprisePk(en *entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	SelectWithDetail(en *entity.EnterpriseUser, pg *Pagination) ([]*entity.EnterpriseUser, error)
	SelectNoPage(en *model.EnterpriseUser) ([]*model.EnterpriseUser, error)
}

func NewEnterpriseUser 

func NewEnterpriseUser(db *gorm.DB, rs *helper.Redis) EnterpriseUser

type EnterpriseUserAttachment 

type EnterpriseUserAttachment interface {
	Create(attachment *entity.EnterpriseUserAttachment) (*entity.EnterpriseUserAttachment, error)
	FindByPk(attachment *entity.EnterpriseUserAttachment) (*entity.EnterpriseUserAttachment, error)
	Select(attachment *entity.EnterpriseUserAttachment, pagination *entity.Pagination) ([]*entity.EnterpriseUserAttachment, error)
	Count(attachment *entity.EnterpriseUserAttachment) (int32, error)
	Delete(attachment *entity.EnterpriseUserAttachment) error
	List(attachment *entity.EnterpriseUserAttachment) ([]*entity.EnterpriseUserAttachment, error)
}

func NewEnterpriseUserAttachment 

func NewEnterpriseUserAttachment(db *gorm.DB) EnterpriseUserAttachment

type ErrorInfo 

type ErrorInfo struct {
	UserID uint
	RoleID uint
	Error  error
}

type Files 

type Files interface {
	Create(*entity.Files) (*entity.Files, error)
	Delete(*entity.Files) error
}

func NewFilesDao 

func NewFilesDao(db *gorm.DB, rs *helper.Redis) Files

NewFilesDao 实例化接口规范实现类

type InspectionPlan 

type InspectionPlan interface {
	Create(*entity.InspectionPlan) (*entity.InspectionPlan, error)
	Delete(*entity.InspectionPlan) error
	Select(*entity.InspectionPlan, *Pagination) ([]*entity.InspectionPlan, error)
	Count(*entity.InspectionPlan) (int32, error)
	Update(*entity.InspectionPlan) (*entity.InspectionPlan, error)
	FindByPk(en *entity.InspectionPlan) (*entity.InspectionPlan, error)
	SelectModel(en *entity.InspectionPlan, pg *Pagination) ([]*model.InspectionPlan, error)
}

func NewInspectionPlan 

func NewInspectionPlan(db *gorm.DB) InspectionPlan

type InspectionPlanPoint 

type InspectionPlanPoint interface {
	Create(*entity.InspectionPlanPoint) (*entity.InspectionPlanPoint, error)
	Delete(*entity.InspectionPlanPoint) error
	DeleteByPlanPk(uu *entity.InspectionPlanPoint) error
	Select(*entity.InspectionPlanPoint, *Pagination) ([]*entity.InspectionPlanPoint, error)
	Count(*entity.InspectionPlanPoint) (int32, error)
	Update(*entity.InspectionPlanPoint) (*entity.InspectionPlanPoint, error)
	FindByPk(en *entity.InspectionPlanPoint) (*entity.InspectionPlanPoint, error)
}

func NewInspectionPlanPoint 

func NewInspectionPlanPoint(db *gorm.DB) InspectionPlanPoint

type InspectionPlanUser 

type InspectionPlanUser interface {
	Create(*entity.InspectionPlanUser) (*entity.InspectionPlanUser, error)
	Delete(*entity.InspectionPlanUser) error
	Select(*entity.InspectionPlanUser, *Pagination) ([]*entity.InspectionPlanUser, error)
	Count(*entity.InspectionPlanUser) (int32, error)
	Update(*entity.InspectionPlanUser) (*entity.InspectionPlanUser, error)
	FindByPk(en *entity.InspectionPlanUser) (*entity.InspectionPlanUser, error)
}

func NewInspectionPlanUser 

func NewInspectionPlanUser(db *gorm.DB) InspectionPlanUser

type InspectionPoint 

type InspectionPoint interface {
	Create(*entity.InspectionPoint) (*entity.InspectionPoint, error)
	Delete(*entity.InspectionPoint) error
	Select(*entity.InspectionPoint, *Pagination) ([]*entity.InspectionPoint, error)
	Count(*entity.InspectionPoint) (int32, error)
	Update(*entity.InspectionPoint) (*entity.InspectionPoint, error)
	FindByPk(en *entity.InspectionPoint) (*entity.InspectionPoint, error)
}

func NewInspectionPoint 

func NewInspectionPoint(db *gorm.DB) InspectionPoint

type InterfaceResource 

type InterfaceResource interface {
	Create(*entity.InterfaceResource) (*entity.InterfaceResource, error)
	Delete(*entity.InterfaceResource) error
	Select(*entity.InterfaceResource, *Pagination) ([]*entity.InterfaceResource, error)
	Count(*entity.InterfaceResource) (int32, error)
	Update(*entity.InterfaceResource) (*entity.InterfaceResource, error)
	FindByPk(en *entity.InterfaceResource) (*entity.InterfaceResource, error)
	SelectAllInterfaceResource(en *entity.InterfaceResource) ([]*entity.InterfaceResource, error)
	FindByInterfaceResourcePkAndName(en *entity.InterfaceResource) (*entity.InterfaceResource, error)
}

func NewInterfaceResource 

func NewInterfaceResource(db *gorm.DB, rs *helper.Redis) InterfaceResource

type LogisticsDelivery 

type LogisticsDelivery interface {
	Select(*entity.LogisticsDelivery, *entity.Pagination) ([]*model.LogisticsDelivery, error)
	Count(*entity.LogisticsDelivery) (int32, error)
	Create(*entity.LogisticsDelivery) (*entity.LogisticsDelivery, error)
	Update(*entity.LogisticsDelivery) error
	Find(en *entity.LogisticsDelivery) (*model.LogisticsDelivery, error)
	ExpenditureStatistics(startTime, endTime time.Time, pk, status int64) (float64, error)
	ListExpenditureStatistics(startTime time.Time, endTime time.Time, pk int64, i int) ([]*model.LogisticsDelivery, error)
}

func NewLogisticsDelivery 

func NewLogisticsDelivery(db *gorm.DB) LogisticsDelivery

type LogisticsInventory 

type LogisticsInventory interface {
	Select(*entity.LogisticsInventory, int32, *entity.Pagination) ([]*model.LogisticsInventory, error)
	Count(*entity.LogisticsInventory, int32) (int32, error)
	Create(*entity.LogisticsInventory) (*entity.LogisticsInventory, error)
	Delete(*entity.LogisticsInventory) error
	Update(*entity.LogisticsInventory) error
	Find(*entity.LogisticsInventory) (*model.LogisticsInventory, error)
}

func NewLogisticsInventory 

func NewLogisticsInventory(db *gorm.DB) LogisticsInventory

type LogisticsPurchase 

type LogisticsPurchase interface {
	Create(purchase *entity.LogisticsPurchase) (*entity.LogisticsPurchase, error)
	Delete(*entity.LogisticsPurchase) error
	Select(*entity.LogisticsPurchase, *entity.Pagination) ([]*model.LogisticsPurchase, error)
	SelectMyPurchase(*entity.LogisticsPurchase, *entity.Pagination) ([]*model.LogisticsPurchase, error)
	Count(*entity.LogisticsPurchase) (int32, error)
	CountMyPurchase(en *entity.LogisticsPurchase) (int32, error)
	Update(*entity.LogisticsPurchase) (*entity.LogisticsPurchase, error)
	FindByPk(en *entity.LogisticsPurchase) (*entity.LogisticsPurchase, error)
}

func NewLogisticsPurchase 

func NewLogisticsPurchase(db *gorm.DB) LogisticsPurchase

type LogisticsWarehousing 

type LogisticsWarehousing interface {
	Create(warehousing *entity.LogisticsWarehousing) (*entity.LogisticsWarehousing, error)
	Select(warehousing *entity.LogisticsWarehousing, pg *entity.Pagination) ([]*model.LogisticsWarehousing, error)
	Count(warehousing *entity.LogisticsWarehousing) (int32, error)
	FindByPk(warehousing *entity.LogisticsWarehousing) (*entity.LogisticsWarehousing, error)
	Update(warehousing *entity.LogisticsWarehousing) (*entity.LogisticsWarehousing, error)
	InputStatistics(time time.Time, time2 time.Time, pk int64) (float64, error)
	ListInputStatistics(time time.Time, time2 time.Time, pk int64) ([]*model.LogisticsWarehousing, error)
}

func NewLogisticsWarehousing 

func NewLogisticsWarehousing(db *gorm.DB) LogisticsWarehousing

type Member 

type Member interface {
	FindLeader(entity.Department) (*model.Member, error)
	Create(*entity.Member) (*entity.Member, error)
	Delete(*entity.Member) error
	Update(*entity.Member) error
	List(*entity.Member) ([]*entity.Member, error)
	CreateMemberUser(member *entity.Member, user *entity.User, userCredentials []*entity.UserCredentials) (*entity.Member, error)
	SelectMemberDetail(m *model.Member, pg *entity.Pagination) ([]*model.Member, error)
	Count(en *model.Member) (int32, error)
	DeleteByEnterprisePkAndUserPk(m *entity.Member) error
	UpdateMemberUser(en *entity.EnterpriseUser) (*entity.EnterpriseUser, error)
	UpdateUserDepartmentRelation(en *entity.Member, departmentPks []int64) error
}

func NewMember 

func NewMember(db *gorm.DB, rs *helper.Redis) Member
type MenuResource interface {
	Create(*entity.MenuResource) (*entity.MenuResource, error)
	Delete(*entity.MenuResource) error
	Select(*entity.MenuResource, *Pagination) ([]*model.MenuResourceModel, error)
	Count(*entity.MenuResource) (int32, error)
	Update(*entity.MenuResource) (*entity.MenuResource, error)
	FindByPk(en *entity.MenuResource) (*entity.MenuResource, error)
	SelectAllMenu(en *entity.MenuResource) ([]*model.MenuResourceModel, error)
}

func NewMenuResource 

func NewMenuResource(db *gorm.DB, rs *helper.Redis) MenuResource

type PageInterface 

type PageInterface interface {
	Create(*entity.PageInterface) (*entity.PageInterface, error)
	Delete(*entity.PageInterface) error
	DeleteByPagePk(uu *entity.PageInterface) error
	Select(*entity.PageInterface, *Pagination) ([]*entity.PageInterface, error)
	Count(*entity.PageInterface) (int32, error)
	Update(*entity.PageInterface) (*entity.PageInterface, error)
	FindByPk(en *entity.PageInterface) (*entity.PageInterface, error)
	SelectAllPageInterface(en *entity.PageInterface) ([]*entity.PageInterface, error)
	FindByPageInterfacePkAndName(en *entity.PageInterface) (*entity.PageInterface, error)
	FindByPagePkAndOperationType(en *entity.PageInterface) ([]*model.PageInterfaceModel, error)
}

func NewPageInterface 

func NewPageInterface(db *gorm.DB, rs *helper.Redis) PageInterface

type PageResource 

type PageResource interface {
	Create(*entity.PageResource) (*entity.PageResource, error)
	Delete(*entity.PageResource) error
	Select(*entity.PageResource, *Pagination) ([]*entity.PageResource, error)
	Count(*entity.PageResource) (int32, error)
	Update(*entity.PageResource) (*entity.PageResource, error)
	FindByPk(en *entity.PageResource) (*entity.PageResource, error)
	SelectAllPageResource(en *entity.PageResource) ([]*entity.PageResource, error)
	FindByPageResourcePkAndName(en *entity.PageResource) (*entity.PageResource, error)
	FindPageAllInterfaceDetailMessageByPk(en *entity.PageResource) (*model.PageResourceWithInterfaceMessageModel, error)
	SelectPageAllInterfaceDetailMessage(en *entity.PageResource) ([]*model.PageResourceWithInterfaceMessageModel, error)
	SelectPageInterfaceDetailMessage(en *entity.PageResource, pg *Pagination) ([]*model.PageResourceWithInterfaceMessageModel, error)
}

func NewPageResource 

func NewPageResource(db *gorm.DB, rs *helper.Redis) PageResource

type Pagination 

type Pagination struct {
	Page    int32  `json:"page"`
	Size    int32  `json:"size"`
	Cursor  int32  `json:"cursor"`
	Total   int32  `json:"total"`
	Keyword string `json:"keyword"`
}

type PatrolPoint 

type PatrolPoint interface {
	Create(route *entity.PatrolPoint) (*entity.PatrolPoint, error)
	Delete(uu *entity.PatrolPoint) error
	Update(uu *entity.PatrolPoint) (*entity.PatrolPoint, error)
	Select(en *entity.PatrolPoint, pg *entity.Pagination) ([]*entity.PatrolPoint, error)
	Count(en *entity.PatrolPoint) (int32, error)
	List(en *entity.PatrolPoint) ([]*entity.PatrolPoint, error)
}

func NewPatrolPoint 

func NewPatrolPoint(db *gorm.DB) PatrolPoint

type PatrolRoute 

type PatrolRoute interface {
	Create(route *entity.PatrolRoute) (*entity.PatrolRoute, error)
	Delete(uu *entity.PatrolRoute) error
	Update(uu *entity.PatrolRoute) (*entity.PatrolRoute, error)
	Select(en *entity.PatrolRoute, pg *entity.Pagination) ([]*model.PatrolRoute, error)
	Count(en *entity.PatrolRoute) (int32, error)
	List(en *entity.PatrolRoute) ([]*model.PatrolRoute, error)
}

func NewPatrolRoute 

func NewPatrolRoute(db *gorm.DB) PatrolRoute

type PatrolRoutePoint 

type PatrolRoutePoint interface {
	Create(route *entity.PatrolRoutePoint) (*entity.PatrolRoutePoint, error)
	Delete(uu *entity.PatrolRoutePoint) error
	Update(uu *entity.PatrolRoutePoint) (*entity.PatrolRoutePoint, error)
	Select(en *entity.PatrolRoutePoint, pg *entity.Pagination) ([]*entity.PatrolRoutePoint, error)
	DeleteByRoutePk(en *entity.PatrolRoutePoint) error
	Count(e *entity.PatrolRoutePoint) (int32, error)
	FindListByRoutePk(en *entity.PatrolRoutePoint) ([]*model.PatrolRoutePoint, error)
	FindByPk(point *entity.PatrolRoutePoint) (*model.PatrolRoutePoint, error)
	FindNext(e *entity.PatrolRoutePoint) (*entity.PatrolRoutePoint, error)
	FindFirst(e *entity.PatrolRoutePoint) (*entity.PatrolRoutePoint, error)
}

func NewPatrolRoutePoint 

func NewPatrolRoutePoint(db *gorm.DB) PatrolRoutePoint

type PatrolRouteRecord 

type PatrolRouteRecord interface {
	Create(route *entity.PatrolRouteRecord) (*entity.PatrolRouteRecord, error)
	Delete(uu *entity.PatrolRouteRecord) error
	Update(uu *entity.PatrolRouteRecord) (*entity.PatrolRouteRecord, error)
	Select(en *entity.PatrolRouteRecord, pg *entity.Pagination) ([]*model.PatrolRouteRecord, error)
	Count(en *entity.PatrolRouteRecord) (int32, error)
	Find(en *entity.PatrolRouteRecord) (*entity.PatrolRouteRecord, error)
}

func NewPatrolRouteRecord 

func NewPatrolRouteRecord(db *gorm.DB) PatrolRouteRecord

type PatrolRouteRecordPoint 

type PatrolRouteRecordPoint interface {
	Create(route *entity.PatrolRouteRecordPoint) (*entity.PatrolRouteRecordPoint, error)
	Delete(uu *entity.PatrolRouteRecordPoint) error
	Update(uu *entity.PatrolRouteRecordPoint) (*entity.PatrolRouteRecordPoint, error)
	Select(en *entity.PatrolRouteRecordPoint, pg *entity.Pagination) ([]*model.PatrolRouteRecordPoint, error)
	Count(en *entity.PatrolRouteRecordPoint) (int32, error)
	FindLast(en *entity.PatrolRouteRecordPoint) (*entity.PatrolRouteRecordPoint, error)
	FindByPk(e *entity.PatrolRoutePoint) (*model.PatrolRouteRecordPoint, error)
	Find(en *entity.PatrolRoutePoint) (*model.PatrolRouteRecordPoint, error)
}

func NewPatrolRouteRecordPoint 

func NewPatrolRouteRecordPoint(db *gorm.DB) PatrolRouteRecordPoint

type Permission 

type Permission interface {
	Create(*entity.Permission) (*entity.Permission, error)
	Delete(*entity.Permission) error
	Select(*entity.Permission, *Pagination) ([]*entity.Permission, error)
	SelectWithPageAndMenu(en *entity.Permission, pg *Pagination) ([]*model.PermissionModel, error)
	Count(*entity.Permission) (int32, error)
	Update(*entity.Permission) (*entity.Permission, error)
	FindByPk(en *entity.Permission) (*entity.Permission, error)
	Find(en *entity.Permission) (*entity.Permission, error)
	ListTenantPermission() ([]*entity.Permission, error)
}

func NewPermission 

func NewPermission(db *gorm.DB, rs *helper.Redis) Permission

type PermissionGroup 

type PermissionGroup interface {
	Create(*entity.PermissionGroup) (*entity.PermissionGroup, error)
	Delete(*entity.PermissionGroup) error
	Select(*entity.PermissionGroup, *Pagination) ([]*entity.PermissionGroup, error)
	Count(*entity.PermissionGroup) (int32, error)
	Update(*entity.PermissionGroup) (*entity.PermissionGroup, error)
	FindByPk(en *entity.PermissionGroup) (*entity.PermissionGroup, error)
	Find(en *entity.PermissionGroup) (*entity.PermissionGroup, error)
	SelectPermissionGroupWithPermission(en *model.PermissionGroupModel, pg *Pagination) ([]*model.PermissionGroupModel, error)
	ListTenantPermissionGroup() ([]*entity.PermissionGroup, error)
	ListSupervisePermissionGroup() ([]*entity.PermissionGroup, error)
	ListUserPlatformPermissionGroup() ([]*entity.PermissionGroup, error)
}

func NewPermissionGroup 

func NewPermissionGroup(db *gorm.DB, rs *helper.Redis) PermissionGroup

type PermissionGroupPermission 

type PermissionGroupPermission interface {
	Create(*entity.PermissionGroupPermission) (*entity.PermissionGroupPermission, error)
	Delete(*entity.PermissionGroupPermission) error
	DeleteByPermissionGroupPk(uu *entity.PermissionGroupPermission) error
	Select(*entity.PermissionGroupPermission, *Pagination) ([]*entity.PermissionGroupPermission, error)
	Count(*entity.PermissionGroupPermission) (int32, error)
	Update(*entity.PermissionGroupPermission) (*entity.PermissionGroupPermission, error)
	SelectAllPermissionGroupPermission(*model.PermissionGroupPermissionModel) ([]*model.PermissionGroupPermissionModel, error)
	FindByPk(en *entity.PermissionGroupPermission) (*entity.PermissionGroupPermission, error)
}

func NewPermissionGroupPermission 

func NewPermissionGroupPermission(db *gorm.DB, rs *helper.Redis) PermissionGroupPermission

type Position 

type Position interface {
	Create(*entity.Position) (*entity.Position, error)
	Delete(*entity.Position) error
	Select(*entity.Position, *Pagination, *time.Time, *time.Time) ([]*model.PositionModel, error)
	Count(*entity.Position, *time.Time, *time.Time) (int32, error)
	Update(*entity.Position) (*entity.Position, error)
	FindByPk(en *entity.Position) (*entity.Position, error)
}

func NewPosition 

func NewPosition(db *gorm.DB, rs *helper.Redis) Position

type Project 

type Project interface {
	Create(*entity.Project) (*entity.Project, error)
	Delete(*entity.Project) error
	Select(*entity.Project, *Pagination) ([]*entity.Project, error)
	Count(*entity.Project) (int32, error)
	Update(*entity.Project) (*entity.Project, error)
	FindByPk(en *entity.Project) (*entity.Project, error)
	SelectForEnterprise(en *model.ProjectQuery, pg *Pagination) ([]*model.Project, int32, error)
	SelectProjectForUserProfession(en *model.ProjectQueryForUserProfession) ([]*model.Project, error)
	SelectNoPage(en *entity.Project) ([]*entity.Project, error)
}

func NewProject 

func NewProject(db *gorm.DB, rs *helper.Redis) Project

type ProjectEnterpriseRelation 

type ProjectEnterpriseRelation interface {
	Create(*entity.ProjectEnterpriseRelation) (*entity.ProjectEnterpriseRelation, error)
	Delete(*entity.ProjectEnterpriseRelation) error
	Select(*entity.ProjectEnterpriseRelation, *Pagination) ([]*entity.ProjectEnterpriseRelation, error)
	SelectWithProject(en *entity.ProjectEnterpriseRelation, pg *Pagination) ([]*model.ProjectEnterpriseRelation, error)
	SelectByProjectPk(en *entity.ProjectEnterpriseRelation) ([]*model.ProjectEnterpriseRelationForRelationEnterprise, error)
	Count(*entity.ProjectEnterpriseRelation) (int32, error)
	Update(*entity.ProjectEnterpriseRelation) (*entity.ProjectEnterpriseRelation, error)
	FindByPk(en *entity.ProjectEnterpriseRelation) (*entity.ProjectEnterpriseRelation, error)
	SelectAllEnterpriseRelation(*entity.ProjectEnterpriseRelation) ([]*entity.ProjectEnterpriseRelation, error)

	SelectProjectRelationEnterprise(en *model.ProjectEnterpriseRelationQuery, pg *Pagination) ([]*model.ProjectEnterpriseRelationForProject, int32, error)
}

func NewProjectEnterpriseRelation 

func NewProjectEnterpriseRelation(db *gorm.DB, rs *helper.Redis) ProjectEnterpriseRelation

type ProjectMember 

type ProjectMember interface {
	Create(*entity.ProjectMember) (*entity.ProjectMember, error)
	Delete(*entity.ProjectMember) error
	Select(*entity.ProjectMember, *Pagination) ([]*entity.ProjectMember, error)
	SelectGetUserPks(en *entity.ProjectMember) ([]int64, error)
	Count(*entity.ProjectMember) (int32, error)
	Update(*entity.ProjectMember) (*entity.ProjectMember, error)
	FindByPk(en *entity.ProjectMember) (*entity.ProjectMember, error)
	FindByUserPkAndProjectPk(en *entity.ProjectMember) (*entity.ProjectMember, error)
	SelectProjectEnterpriseUser(en *model.ProjectMemberQueryBody, pg *Pagination) ([]*model.ProjectMember, int32, error)
}

func NewProjectMember 

func NewProjectMember(db *gorm.DB, rs *helper.Redis) ProjectMember

type ProjectPost 

type ProjectPost interface {
	Create(*entity.ProjectPost) (*entity.ProjectPost, error)
	Delete(*entity.ProjectPost) error
	Select(*entity.ProjectPost, *Pagination) ([]*entity.ProjectPost, error)
	Count(*entity.ProjectPost) (int32, error)
	Update(*entity.ProjectPost) (*entity.ProjectPost, error)
	FindByPk(en *entity.ProjectPost) (*entity.ProjectPost, error)
	SelectModel(en *entity.ProjectPost, pg *Pagination) ([]*model.ProjectPost, error)
}

func NewProjectPost 

func NewProjectPost(db *gorm.DB, rs *helper.Redis) ProjectPost

type Role 

type Role interface {
	Create(*entity.Role) (*entity.Role, error)
	Delete(*entity.Role) error
	Select(*entity.Role, *Pagination) ([]*entity.Role, error)
	Count(*entity.Role) (int32, error)
	Update(*entity.Role) (*entity.Role, error)
	FindByPk(en *entity.Role) (*entity.Role, error)
	SelectWithDetail(en *entity.Role, pg *Pagination) ([]*model.RoleModel, error)
}

func NewRole 

func NewRole(db *gorm.DB, rs *helper.Redis) Role

type RoleGroup 

type RoleGroup interface {
	Create(*entity.RoleGroup) (*entity.RoleGroup, error)
	Delete(*entity.RoleGroup) error
	Select(*entity.RoleGroup, *Pagination) ([]*entity.RoleGroup, error)
	Count(*entity.RoleGroup) (int32, error)
	Update(*entity.RoleGroup) (*entity.RoleGroup, error)
	FindByPk(*entity.RoleGroup) (*entity.RoleGroup, error)
	SelectWithRoleMessage(en *entity.RoleGroup, pg *Pagination) ([]*model.RoleGroupWithRoleMessageModel, error)
	SelectAllRoleWithRoleMessage(en *entity.RoleGroup) ([]*model.RoleGroupWithRoleMessageModel, error)
}

func NewRoleGroup 

func NewRoleGroup(db *gorm.DB, rs *helper.Redis) RoleGroup

type RoleGroupPermission 

type RoleGroupPermission interface {
	Create(*entity.RoleGroupPermission) (*entity.RoleGroupPermission, error)
	Delete(*entity.RoleGroupPermission) error
	DeleteByGroupPk(uu *entity.RoleGroupPermission) error
	Select(*entity.RoleGroupPermission, *Pagination) ([]*entity.RoleGroupPermission, error)
	SelectAllRoleGroupPermission(en *entity.RoleGroupPermission) ([]*entity.RoleGroupPermission, error)
	Count(*entity.RoleGroupPermission) (int32, error)
	Update(*entity.RoleGroupPermission) (*entity.RoleGroupPermission, error)
	FindByPk(*entity.RoleGroupPermission) (*entity.RoleGroupPermission, error)
	SelectRoleGroupPermissionByRoleGroupPk(en *entity.RoleGroupPermission) ([]*model.RoleGroupPermissionModel, error)
	SelectPermissionByRoleGroupPK(roleGroupPk int64) ([]*entity.Permission, error)
}

func NewRoleGroupPermission 

func NewRoleGroupPermission(db *gorm.DB, rs *helper.Redis) RoleGroupPermission

type RolePermission 

type RolePermission interface {
	Create(*entity.RolePermission) (*entity.RolePermission, error)
	Delete(*entity.RolePermission) error
	DeleteByRolePk(uu *entity.RolePermission) error
	Select(*entity.RolePermission, *Pagination) ([]*entity.RolePermission, error)
	Count(*entity.RolePermission) (int32, error)
	Update(*entity.RolePermission) (*entity.RolePermission, error)
	SelectAllRolePermission(en *entity.RolePermission) ([]*entity.RolePermission, error)
	SelectRolePermissionByRolePk(en *entity.RolePermission) ([]*model.RolePermissionModel, error)
	SelectRolePermissionByRolePkTest(en *entity.RolePermission) ([]*model.RolePermissionModel, error)
	SelectPermissionByRolePK(rolePk int64) ([]*entity.Permission, error)
	FindByPk(en *entity.RolePermission) (*entity.RolePermission, error)
}

func NewRolePermission 

func NewRolePermission(db *gorm.DB, rs *helper.Redis) RolePermission

type Sms 

type Sms interface {
	Create(sms2 *entity.Sms) (*entity.Sms, error)
}

func NewSms 

func NewSms(db *gorm.DB, rs *helper.Redis) Sms

type TemporaryWorker 

type TemporaryWorker interface {
	Create(record *entity.TemporaryWorker) (*entity.TemporaryWorker, error)
	Update(record *entity.TemporaryWorker) (*entity.TemporaryWorker, error)
	Count(en *model.TemporaryWorker) (int32, error)
	SelectDetail(en *model.TemporaryWorker, pg *entity.Pagination) ([]*model.TemporaryWorker, error)
	DeleteByEnterpriseUserPk(worker *entity.TemporaryWorker) error
}

func NewTemporaryWorker 

func NewTemporaryWorker(db *gorm.DB) TemporaryWorker

type TurnoverRecord 

type TurnoverRecord interface {
	Create(record *entity.TurnoverRecord) (*entity.TurnoverRecord, error)
	Update(record *entity.TurnoverRecord) (*entity.TurnoverRecord, error)
	SelectDetail(en *model.TurnoverRecord, pg *entity.Pagination) ([]*model.TurnoverRecord, error)
	Count(en *model.TurnoverRecord) (int32, error)
	Select(en *entity.TurnoverRecord, pg *entity.Pagination) ([]*entity.TurnoverRecord, error)
	Find(e *entity.TurnoverRecord) (*entity.TurnoverRecord, error)
}

func NewTurnoverRecord 

func NewTurnoverRecord(db *gorm.DB) TurnoverRecord

type User 

type User interface {
	Find(*entity.User) (*entity.User, error)
	Create(*entity.User) (*entity.User, error)
	Update(*entity.User) error
	Count(*entity.User) (int64, error)
	SelectAccount(*entity.User, *entity.Pagination) ([]*model.QfqzAccountModel, error)
	SelectEnterpriseAccount(*model.QfqzAccountModelForEnterprise, *entity.Pagination) ([]*model.QfqzAccountModelForEnterprise, error)
	CountEnterprise(user *model.QfqzAccountModelForEnterprise) (int64, error)
	SelectUser(*entity.User, *entity.Pagination) ([]*model.QfqzUserModel, error)
	FindUser(*entity.User) (*model.QfqzUserModel, error)
	FindOaOpenid(string) string
}

func NewUser 

func NewUser(db *gorm.DB, rs *helper.Redis) User

type UserClient 

type UserClient interface {
	FindList(*entity.UserClient) ([]*entity.UserClient, error)
	DeleteByUserPkAndClientType(*entity.UserClient) error
	SaveUserClientSubscribe(*entity.UserClient)
	CreateUserClient(*entity.UserClient) error
	UpdateUserClientSubscribe(*entity.UserClient) error
	Find(*entity.UserClient) (*entity.UserClient, error)
}

func NewUserClient 

func NewUserClient(db *gorm.DB, rs *helper.Redis) UserClient

type UserCredentials 

type UserCredentials interface {
	FindList(client *entity.UserCredentials) ([]*entity.UserCredentials, error)
	FindCardByUserPk(credentials *entity.UserCredentials) (*entity.UserCredentials, error)
	Create(c *entity.UserCredentials) (*entity.UserCredentials, error)
	Find(p *entity.UserCredentials) (*entity.UserCredentials, error)
	Delete(p *entity.UserCredentials) error
	Update(*entity.UserCredentials) error
}

func NewUserCredentials 

func NewUserCredentials(db *gorm.DB, rs *helper.Redis) UserCredentials

type UserEntry 

type UserEntry interface {
	Create(m *entity.UserEntry) (*entity.UserEntry, error)
	Select(m *model.UserEntryModel, page *entity.Pagination, st, et *time.Time) ([]*model.UserEntryModel, error)
	Count(m *model.UserEntryModel, st, et *time.Time) (int32, error)
	Update(m *entity.UserEntry) (*entity.UserEntry, error)
	FindByPk(en *entity.UserEntry) (*entity.UserEntry, error)
	Find(en *entity.UserEntry) (*entity.UserEntry, error)
}

func NewUserEntry 

func NewUserEntry(db *gorm.DB, rs *helper.Redis) UserEntry

type UserPermission 

type UserPermission interface {
	Create(*entity.UserPermission) (*entity.UserPermission, error)
	CreateForCorporate(en *entity.UserPermission) error
	Delete(*entity.UserPermission) error
	DeleteByUserPkAndEnterprisePk(uu *entity.UserPermission) error
	Select(*entity.UserPermission, *Pagination) ([]*entity.UserPermission, error)
	FindList(p *entity.UserPermission) ([]*entity.UserPermission, error)
	Count(p *entity.UserPermission) (int32, error)
	Update(*entity.UserPermission) (*entity.UserPermission, error)
	SelectAllUserPermission(en *entity.UserPermission) ([]*entity.UserPermission, error)
	SelectWithUser(en *entity.UserPermission, pg *Pagination) ([]*model.UserPermissionModel, error)
	SelectWithEnterpriseUser(en *entity.UserPermission, pg *Pagination) ([]*model.UserPermissionForEnterprise, error)
	CheckUserEnterprisePlatformPermission(userPk, enterprisePk int64) (bool, error)
	CheckUserEnterpriseAppletPermission(userPk, enterprisePk int64) (bool, error)
	FindByPk(en *entity.UserPermission) (*entity.UserPermission, error)
	DeleteRedisPermission(enterprisePk, userPk int64) error
}

func NewUserPermission 

func NewUserPermission(db *gorm.DB, rs *helper.Redis) UserPermission

type UserProfession 

type UserProfession interface {
	Create(*entity.UserProfession) (*entity.UserProfession, error)
	Count(*entity.UserProfession) (int32, error)
	SelectUserProfession(en *model.UserProfessionQuery, pg *Pagination) ([]*model.UserProfession, int32, error)
	SelectUserProfessionForPlatform(en *model.UserProfessionForPlatformQuery, pg *Pagination) ([]*model.UserProfessionForPlatform, int32, error)
	GetProfessionUsers(model *model.QfqzProfessionUserModel, pg *entity.Pagination) ([]*model.QfqzProfessionUserModel, int32, error)
	SelectByUserPk(en *entity.UserProfession) ([]*model.UserProfessionWithEnterpriseNameAndStatus, error)
	SelectUserProfessionForSupervisePlatform(en *model.UserProfessionForSupervisePlatformQuery, pg *Pagination) ([]*model.UserProfessionForPlatform, int32, error)
}

func NewUserProfession 

func NewUserProfession(db *gorm.DB, rs *helper.Redis) UserProfession

type UserRealNameAuthenticationLog 

type UserRealNameAuthenticationLog interface {
	Create(*entity.UserRealNameAuthenticationLog) (*entity.UserRealNameAuthenticationLog, error)
	Delete(*entity.UserRealNameAuthenticationLog) error
	Select(*entity.UserRealNameAuthenticationLog, *Pagination) ([]*entity.UserRealNameAuthenticationLog, error)
	Count(*entity.UserRealNameAuthenticationLog) (int32, error)
	Update(*entity.UserRealNameAuthenticationLog) (*entity.UserRealNameAuthenticationLog, error)
	FindByPk(en *entity.UserRealNameAuthenticationLog) (*entity.UserRealNameAuthenticationLog, error)
}

func NewUserRealNameAuthenticationLog 

func NewUserRealNameAuthenticationLog(db *gorm.DB, rs *helper.Redis) UserRealNameAuthenticationLog

type WorkSchedule 

type WorkSchedule interface {
	Create(*entity.WorkSchedule) (*entity.WorkSchedule, error)
	Delete(*entity.WorkSchedule) error
	Select(*entity.WorkSchedule, *Pagination) ([]*entity.WorkSchedule, error)
	Count(*entity.WorkSchedule) (int32, error)
	Update(*entity.WorkSchedule) (*entity.WorkSchedule, error)
	FindByPk(en *entity.WorkSchedule) (*entity.WorkSchedule, error)
}

func NewWorkSchedule 

func NewWorkSchedule(db *gorm.DB) WorkSchedule

type WorkSchedulePost 

type WorkSchedulePost interface {
	Create(*entity.WorkSchedulePost) (*entity.WorkSchedulePost, error)
	Delete(*entity.WorkSchedulePost) error
	Select(*entity.WorkSchedulePost, *Pagination) ([]*entity.WorkSchedulePost, error)
	Count(*entity.WorkSchedulePost) (int32, error)
	Update(*entity.WorkSchedulePost) (*entity.WorkSchedulePost, error)
	FindByPk(en *entity.WorkSchedulePost) (*entity.WorkSchedulePost, error)
	SelectModelByPostPkOrSchedulePK(en *entity.WorkSchedulePost, pg *Pagination) ([]*model.WorkSchedulePost, error)
}

func NewWorkSchedulePost 

func NewWorkSchedulePost(db *gorm.DB) WorkSchedulePost

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.