system

package
v0.0.0-...-14a2a1b Latest Latest
Warning

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

 Go to latest Published: Sep 22, 2022 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ConfigAddReq 

type ConfigAddReq struct {
	g.Meta `path:"/config/add" tags:"系统参数管理" method:"post" summary:"添加系统参数"`
	*ConfigReq
}

type ConfigAddRes 

type ConfigAddRes struct {
}

type ConfigDeleteReq 

type ConfigDeleteReq struct {
	g.Meta `path:"/config/delete" tags:"系统参数管理" method:"delete" summary:"删除系统参数"`
	Ids    []int `p:"ids"`
}

type ConfigDeleteRes 

type ConfigDeleteRes struct {
}

type ConfigEditReq 

type ConfigEditReq struct {
	g.Meta   `path:"/config/edit" tags:"系统参数管理" method:"put" summary:"修改系统参数"`
	ConfigId int64 `p:"configId" v:"required|min:1#主键ID不能为空|主键ID参数错误"`
	*ConfigReq
}

type ConfigEditRes 

type ConfigEditRes struct {
}

type ConfigGetReq 

type ConfigGetReq struct {
	g.Meta `path:"/config/get" tags:"系统参数管理" method:"get" summary:"获取系统参数"`
	Id     int `p:"id"`
}

type ConfigGetRes 

type ConfigGetRes struct {
	g.Meta `mime:"application/json"`
	Data   *commonEntity.SysConfig `json:"data"`
}

type ConfigReq 

type ConfigReq struct {
	ConfigName  string `p:"configName"  v:"required#参数名称不能为空"`
	ConfigKey   string `p:"configKey"  v:"required#参数键名不能为空"`
	ConfigValue string `p:"configValue"  v:"required#参数键值不能为空"`
	ConfigType  int    `p:"configType"    v:"required|in:0,1#系统内置不能为空|系统内置类型只能为0或1"`
	Remark      string `p:"remark"`
}

type ConfigSearchReq 

type ConfigSearchReq struct {
	g.Meta     `path:"/config/list" tags:"系统参数管理" method:"get" summary:"系统参数列表"`
	ConfigName string `p:"configName"` //参数名称
	ConfigKey  string `p:"configKey"`  //参数键名
	ConfigType string `p:"configType"` //状态
	commonApi.PageReq
}

type ConfigSearchRes 

type ConfigSearchRes struct {
	g.Meta `mime:"application/json"`
	List   []*commonEntity.SysConfig `json:"list"`
	commonApi.ListRes
}

type DbInitCreateDbReq 

type DbInitCreateDbReq struct {
	g.Meta       `path:"/dbInit/createDb" tags:"系统初始化" method:"post" summary:"创建配置文件"`
	DbHost       string `json:"dbHost" p:"dbHost" v:"required#数据库地址必须"`
	DbPort       int    `json:"dbPort" p:"dbPort" v:"required#数据库端口必须"`
	DbUser       string `json:"dbUser" p:"dbUser" v:"required#数据库用户名称必须"`
	DbPass       string `json:"dbPass"`
	DbName       string `json:"dbName" p:"dbName" v:"required#数据库名称必须"`
	DbCharset    string `json:"dbCharset" p:"dbCharset" v:"required#数据库编码必须"`
	RedisAddress string `json:"redisAddress" p:"redisAddress" v:"required#Redis地址必须"`
	RedisPort    int    `json:"redisPort" p:"redisPort" v:"required#Redis端口必须"`
	RedisDb      int    `json:"redisDb" p:"redisDb" v:"required#Redis索引必须"`
	RedisPass    string `json:"redisPass"`
}

func (*DbInitCreateDbReq) ToDbInitConfig 

func (req *DbInitCreateDbReq) ToDbInitConfig() *model.DbInitConfig

type DbInitCreateDbRes 

type DbInitCreateDbRes bool

type DbInitGetEnvInfoReq 

type DbInitGetEnvInfoReq struct {
	g.Meta `path:"/dbInit/getEnvInfo" tags:"系统初始化" method:"get" summary:"获取环境信息"`
}

type DbInitGetEnvInfoRes 

type DbInitGetEnvInfoRes g.Map

type DbInitIsInitReq 

type DbInitIsInitReq struct {
	g.Meta `path:"/dbInit/isInit" tags:"系统初始化" method:"get" summary:"系统初始化"`
}

type DbInitIsInitRes 

type DbInitIsInitRes bool

type DictDataAddReq 

type DictDataAddReq struct {
	g.Meta `path:"/dict/data/add" tags:"字典管理" method:"post" summary:"添加字典数据"`
	*DictDataReq
}

type DictDataAddRes 

type DictDataAddRes struct {
}

type DictDataDeleteReq 

type DictDataDeleteReq struct {
	g.Meta `path:"/dict/data/delete" tags:"字典管理" method:"delete" summary:"删除字典数据"`
	Ids    []int `p:"ids"`
}

type DictDataDeleteRes 

type DictDataDeleteRes struct {
}

type DictDataEditReq 

type DictDataEditReq struct {
	g.Meta   `path:"/dict/data/edit" tags:"字典管理" method:"put" summary:"修改字典数据"`
	DictCode int `p:"dictCode" v:"required|min:1#主键ID不能为空|主键ID不能小于1"`
	*DictDataReq
}

type DictDataEditRes 

type DictDataEditRes struct {
}

type DictDataGetReq 

type DictDataGetReq struct {
	g.Meta   `path:"/dict/data/get" tags:"字典管理" method:"get" summary:"获取字典数据"`
	DictCode uint `p:"dictCode"`
}

type DictDataGetRes 

type DictDataGetRes struct {
	g.Meta `mime:"application/json"`
	Dict   *commonEntity.SysDictData `json:"dict"`
}

type DictDataReq 

type DictDataReq struct {
	DictLabel string `p:"dictLabel"  v:"required#字典标签不能为空"`
	DictValue string `p:"dictValue"  v:"required#字典键值不能为空"`
	DictType  string `p:"dictType"  v:"required#字典类型不能为空"`
	DictSort  int    `p:"dictSort"  v:"integer#排序只能为整数"`
	CssClass  string `p:"cssClass"`
	ListClass string `p:"listClass"`
	IsDefault int    `p:"isDefault" v:"required|in:0,1#系统默认不能为空|默认值只能为0或1"`
	Status    int    `p:"status"    v:"required|in:0,1#状态不能为空|状态只能为0或1"`
	Remark    string `p:"remark"`
}

type DictDataSearchReq 

type DictDataSearchReq struct {
	g.Meta    `path:"/dict/data/list" tags:"字典管理" method:"get" summary:"字典数据分页"`
	DictType  string `p:"dictType"`  //字典类型
	DictLabel string `p:"dictLabel"` //字典标签
	Status    string `p:"status"`    //状态
	commonApi.PageReq
}

DictDataSearchReq 分页请求参数

type DictDataSearchRes 

type DictDataSearchRes struct {
	g.Meta `mime:"application/json"`
	List   []*commonEntity.SysDictData `json:"list"`
	commonApi.ListRes
}

DictDataSearchRes 字典数据结果

type DictDataSimpleReq 

type DictDataSimpleReq struct {
	g.Meta `path:"/dict/data/simple/list" tags:"字典管理" method:"get" summary:"字典数据列表"`
}

type DictDataSimpleRes 

type DictDataSimpleRes struct {
	g.Meta `mime:"application/json"`
	List   []*commonModel.DictDataRes `json:"list"`
}

type DictTypeAddReq 

type DictTypeAddReq struct {
	g.Meta   `path:"/dict/type/add" tags:"字典管理" method:"post" summary:"添加字典类型"`
	DictName string `p:"dictName"  v:"required#字典名称不能为空"`
	DictType string `p:"dictType"  v:"required#字典类型不能为空"`
	Status   uint   `p:"status"  v:"required|in:0,1#状态不能为空|状态只能为0或1"`
	Remark   string `p:"remark"`
}

type DictTypeAddRes 

type DictTypeAddRes struct {
}

type DictTypeDeleteReq 

type DictTypeDeleteReq struct {
	g.Meta  `path:"/dict/type/delete" tags:"字典管理" method:"delete" summary:"删除字典类型"`
	DictIds []int `p:"dictIds" v:"required#字典类型id不能为空"`
}

type DictTypeDeleteRes 

type DictTypeDeleteRes struct {
}

type DictTypeEditReq 

type DictTypeEditReq struct {
	g.Meta   `path:"/dict/type/edit" tags:"字典管理" method:"put" summary:"修改字典类型"`
	DictId   int64  `p:"dictId" v:"required|min:1#主键ID不能为空|主键ID必须为大于0的值"`
	DictName string `p:"dictName"  v:"required#字典名称不能为空"`
	DictType string `p:"dictType"  v:"required#字典类型不能为空"`
	Status   uint   `p:"status"  v:"required|in:0,1#状态不能为空|状态只能为0或1"`
	Remark   string `p:"remark"`
}

type DictTypeEditRes 

type DictTypeEditRes struct {
}

type DictTypeGetReq 

type DictTypeGetReq struct {
	g.Meta `path:"/dict/type/get" tags:"字典管理" method:"get" summary:"获取字典类型"`
	DictId uint `p:"dictId" v:"required#类型id不能为空"`
}

type DictTypeGetRes 

type DictTypeGetRes struct {
	g.Meta   `mime:"application/json"`
	DictType *commonEntity.SysDictType `json:"dictType"`
}

type DictTypeSearchReq 

type DictTypeSearchReq struct {
	g.Meta   `path:"/dict/type/list" tags:"字典管理" method:"get" summary:"字典类型列表"`
	DictName string `p:"dictName"` //字典名称
	DictType string `p:"dictType"` //字典类型
	Status   string `p:"status"`   //字典状态
	commonApi.PageReq
}

type DictTypeSearchRes 

type DictTypeSearchRes struct {
	g.Meta       `mime:"application/json"`
	DictTypeList []*commonModel.SysDictTypeInfoRes `json:"dictTypeList"`
	commonApi.ListRes
}

type GetDictReq 

type GetDictReq struct {
	g.Meta        `path:"/dict/data/getDictData" tags:"字典管理" method:"get" summary:"获取字典数据公共方法"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	DictType      string `p:"dictType" v:"required#字典类型不能为空"`
	DefaultValue  string `p:"defaultValue"`
}

GetDictReq 获取字典信息请求参数

type GetDictRes 

type GetDictRes struct {
	g.Meta `mime:"application/json"`
	Info   *commonModel.DictTypeRes   `json:"info"`
	Values []*commonModel.DictDataRes `json:"values"`
}

GetDictRes 完整的一个字典信息

type LoginLogClearReq 

type LoginLogClearReq struct {
	g.Meta `path:"/loginLog/clear" tags:"登录日志管理" method:"delete" summary:"清除日志"`
}

type LoginLogClearRes 

type LoginLogClearRes struct {
}

type LoginLogDelReq 

type LoginLogDelReq struct {
	g.Meta `path:"/loginLog/delete" tags:"登录日志管理" method:"delete" summary:"删除日志"`
	Ids    []int `p:"ids" v:"required#ids必须"`
}

type LoginLogDelRes 

type LoginLogDelRes struct {
}

type LoginLogSearchReq 

type LoginLogSearchReq struct {
	g.Meta        `path:"/loginLog/list" tags:"登录日志管理" method:"get" summary:"日志列表"`
	LoginName     string `p:"userName"`      //登陆名
	Status        string `p:"status"`        //状态
	Ipaddr        string `p:"ipaddr"`        //登录地址
	SortName      string `p:"orderByColumn"` //排序字段
	SortOrder     string `p:"isAsc"`         //排序方式
	LoginLocation string `p:"loginLocation"` //登录地点
	commonApi.PageReq
}

LoginLogSearchReq 查询列表请求参数

type LoginLogSearchRes 

type LoginLogSearchRes struct {
	g.Meta `mime:"application/json"`
	commonApi.ListRes
	List []*entity.SysLoginLog `json:"list"`
}

type MonitorSearchReq 

type MonitorSearchReq struct {
	g.Meta `path:"/monitor/server" tags:"服务监控" method:"get" summary:"服务监控"`
}

type MonitorSearchRes 

type MonitorSearchRes g.Map

type RoleAddReq 

type RoleAddReq struct {
	g.Meta    `path:"/role/add" tags:"角色管理" method:"post" summary:"添加角色"`
	Name      string `p:"name" v:"required#角色名称不能为空"`
	Status    uint   `p:"status"    `
	ListOrder uint   `p:"listOrder" `
	Remark    string `p:"remark"    `
	MenuIds   []uint `p:"menuIds"`
}

type RoleAddRes 

type RoleAddRes struct {
}

type RoleDeleteReq 

type RoleDeleteReq struct {
	g.Meta `path:"/role/delete" tags:"角色管理" method:"delete" summary:"删除角色"`
	Ids    []int64 `p:"ids" v:"required#角色id不能为空"`
}

type RoleDeleteRes 

type RoleDeleteRes struct {
}

type RoleEditReq 

type RoleEditReq struct {
	g.Meta    `path:"/role/edit" tags:"角色管理" method:"put" summary:"修改角色"`
	Id        int64  `p:"id" v:"required#角色id必须"`
	Name      string `p:"name" v:"required#角色名称不能为空"`
	Status    uint   `p:"status"    `
	ListOrder uint   `p:"listOrder" `
	Remark    string `p:"remark"    `
	MenuIds   []uint `p:"menuIds"`
}

type RoleEditRes 

type RoleEditRes struct {
}

type RoleGetParamsReq 

type RoleGetParamsReq struct {
	g.Meta `path:"/role/getParams" tags:"角色管理" method:"get" summary:"角色编辑参数"`
}

type RoleGetParamsRes 

type RoleGetParamsRes struct {
	g.Meta `mime:"application/json"`
	Menu   []*model.SysAuthRuleInfoRes `json:"menu"`
}

type RoleGetReq 

type RoleGetReq struct {
	g.Meta `path:"/role/get" tags:"角色管理" method:"get" summary:"获取角色信息"`
	Id     uint `p:"id" v:"required#角色id不能为空""`
}

type RoleGetRes 

type RoleGetRes struct {
	g.Meta  `mime:"application/json"`
	Role    *entity.SysRole `json:"role"`
	MenuIds []int           `json:"menuIds"`
}

type RoleListReq 

type RoleListReq struct {
	g.Meta   `path:"/role/list" tags:"角色管理" method:"get" summary:"角色列表"`
	RoleName string `p:"roleName"`   //参数名称
	Status   string `p:"roleStatus"` //状态
	commonApi.PageReq
}

type RoleListRes 

type RoleListRes struct {
	g.Meta `mime:"application/json"`
	commonApi.ListRes
	List []*entity.SysRole `json:"list"`
}

type RuleAddReq 

type RuleAddReq struct {
	g.Meta        `path:"/menu/add" tags:"菜单管理" method:"post" summary:"添加菜单"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	MenuType      uint   `p:"menuType"  v:"min:0|max:2#菜单类型最小值为:min|菜单类型最大值为:max"`
	Pid           uint   `p:"parentId"  v:"min:0"`
	Name          string `p:"name" v:"required#请填写规则名称"`
	Title         string `p:"menuName" v:"required|length:1,100#请填写标题|标题长度在:min到:max位"`
	Icon          string `p:"icon"`
	Weigh         int    `p:"menuSort" `
	Condition     string `p:"condition" `
	Remark        string `p:"remark" `
	IsHide        uint   `p:"isHide"`
	Path          string `p:"path"`
	Redirect      string `p:"redirect"` // 路由重定向
	Roles         []uint `p:"roles"`    // 角色ids
	Component     string `p:"component" v:"required-if:menuType,1#组件路径不能为空"`
	IsLink        uint   `p:"isLink"`
	IsIframe      uint   `p:"isIframe"`
	IsCached      uint   `p:"isKeepAlive"`
	IsAffix       uint   `p:"isAffix"`
	LinkUrl       string `p:"linkUrl"`
}

type RuleAddRes 

type RuleAddRes struct {
}

type RuleDeleteReq 

type RuleDeleteReq struct {
	g.Meta        `path:"/menu/delete" tags:"菜单管理" method:"delete" summary:"删除菜单"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	Ids           []int  `p:"ids" v:"required#菜单id必须"`
}

type RuleDeleteRes 

type RuleDeleteRes struct {
}

type RuleGetParamsReq 

type RuleGetParamsReq struct {
	g.Meta        `path:"/menu/getParams" tags:"菜单管理" method:"get" summary:"获取添加、编辑菜单相关参数"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
}

type RuleGetParamsRes 

type RuleGetParamsRes struct {
	g.Meta `mime:"application/json"`
	Roles  []*entity.SysRole           `json:"roles"`
	Menus  []*model.SysAuthRuleInfoRes `json:"menus"`
}

type RuleInfoReq 

type RuleInfoReq struct {
	g.Meta        `path:"/menu/get" tags:"菜单管理" method:"get" summary:"获取菜单信息"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	Id            uint   `p:"required#菜单id必须"`
}

type RuleInfoRes 

type RuleInfoRes struct {
	g.Meta  `mime:"application/json"`
	Rule    *entity.SysAuthRule `json:"rule"`
	RoleIds []uint              `json:"roleIds"`
}

type RuleListRes 

type RuleListRes struct {
	g.Meta `mime:"application/json"`
	Rules  []*model.SysAuthRuleTreeRes `json:"rules"`
}

type RuleSearchReq 

type RuleSearchReq struct {
	g.Meta        `path:"/menu/list" tags:"菜单管理" method:"get" summary:"菜单列表"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	Title         string `p:"menuName" `
	Component     string `p:"component"`
}

type RuleUpdateReq 

type RuleUpdateReq struct {
	g.Meta        `path:"/menu/update" tags:"菜单管理" method:"put" summary:"修改菜单"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
	Id            uint   `p:"id" v:"required#id必须"`
	MenuType      uint   `p:"menuType"  v:"min:0|max:2#菜单类型最小值为:min|菜单类型最大值为:max"`
	Pid           uint   `p:"parentId"  v:"min:0"`
	Name          string `p:"name" v:"required#请填写规则名称"`
	Title         string `p:"menuName" v:"required|length:1,100#请填写标题|标题长度在:min到:max位"`
	Icon          string `p:"icon"`
	Weigh         int    `p:"menuSort" `
	Condition     string `p:"condition" `
	Remark        string `p:"remark" `
	IsHide        uint   `p:"isHide"`
	Path          string `p:"path"`
	Redirect      string `p:"redirect"` // 路由重定向
	Roles         []uint `p:"roles"`    // 角色ids
	Component     string `p:"component" v:"required-if:menuType,1#组件路径不能为空"`
	IsLink        uint   `p:"isLink"`
	IsIframe      uint   `p:"isIframe"`
	IsCached      uint   `p:"isKeepAlive"`
	IsAffix       uint   `p:"isAffix"`
	LinkUrl       string `p:"linkUrl"`
}

type RuleUpdateRes 

type RuleUpdateRes struct {
}

type SetUserReq 

type SetUserReq struct {
	Email    string  `p:"email" v:"email#邮箱格式错误"` //邮箱
	NickName string  `p:"nickName" v:"required#用户昵称不能为空"`
	Mobile   string  `p:"mobile" v:"required|phone#手机号不能为空|手机号格式错误"`
	PostIds  []int64 `p:"postIds"`
	Remark   string  `p:"remark"`
	RoleIds  []int64 `p:"roleIds"`
	Sex      int     `p:"sex"`
	Status   uint    `p:"status"`
	IsAdmin  int     `p:"isAdmin"` // 是否后台管理员 1 是  0   否
}

SetUserReq 添加修改用户公用请求字段

type UserAddReq 

type UserAddReq struct {
	g.Meta `path:"/user/add" tags:"用户管理" method:"post" summary:"添加用户"`
	*SetUserReq
	UserName string `p:"userName" v:"required#用户账号不能为空"`
	Password string `` /* 139-byte string literal not displayed */
	UserSalt string
}

UserAddReq 添加用户参数

type UserAddRes 

type UserAddRes struct {
}

type UserDeleteReq 

type UserDeleteReq struct {
	g.Meta `path:"/user/delete" tags:"用户管理" method:"delete" summary:"删除用户"`
	Ids    []int `p:"ids"`
}

type UserDeleteRes 

type UserDeleteRes struct {
}

type UserEditReq 

type UserEditReq struct {
	g.Meta `path:"/user/edit" tags:"用户管理" method:"put" summary:"修改用户"`
	*SetUserReq
	UserId int64 `p:"userId" v:"required#用户id不能为空"`
}

UserEditReq 修改用户参数

type UserEditRes 

type UserEditRes struct {
}

type UserGetEditReq 

type UserGetEditReq struct {
	g.Meta `path:"/user/getEdit" tags:"用户管理" method:"get" summary:"获取用户信息"`
	Id     uint64 `p:"id"`
}

type UserGetEditRes 

type UserGetEditRes struct {
	g.Meta         `mime:"application/json"`
	User           *entity.SysUser `json:"user"`
	CheckedRoleIds []uint          `json:"checkedRoleIds"`
	CheckedPosts   []int64         `json:"checkedPosts"`
}

type UserGetParamsReq 

type UserGetParamsReq struct {
	g.Meta `path:"/user/params" tags:"用户管理" method:"get" summary:"用户维护参数获取"`
}

type UserGetParamsRes 

type UserGetParamsRes struct {
	g.Meta   `mime:"application/json"`
	RoleList []*entity.SysRole `json:"roleList"`
	Posts    []*entity.SysPost `json:"posts"`
}

type UserLoginOutReq 

type UserLoginOutReq struct {
	g.Meta        `path:"/loginOut" tags:"登录" method:"delete" summary:"退出登录"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
}

type UserLoginOutRes 

type UserLoginOutRes struct {
}

type UserLoginReq 

type UserLoginReq struct {
	g.Meta     `path:"/login" tags:"登录" method:"post" summary:"用户登录"`
	Username   string `p:"username" v:"required#用户名不能为空"`
	Password   string `p:"password" v:"required#密码不能为空"`
	VerifyCode string `p:"verifyCode" v:"required#验证码不能为空"`
	VerifyKey  string `p:"verifyKey"`
}

type UserLoginRes 

type UserLoginRes struct {
	g.Meta      `mime:"application/json"`
	UserInfo    *model.LoginUserRes `json:"userInfo"`
	Token       string              `json:"token"`
	MenuList    []*model.UserMenus  `json:"menuList"`
	Permissions []string            `json:"permissions"`
}

type UserMenusReq 

type UserMenusReq struct {
	g.Meta        `path:"/user/getUserMenus" tags:"用户管理" method:"get" summary:"获取用户菜单"`
	Authorization string `p:"Authorization" in:"header" dc:"Bearer {{token}}"`
}

type UserMenusRes 

type UserMenusRes struct {
	g.Meta      `mime:"application/json"`
	MenuList    []*model.UserMenus `json:"menuList"`
	Permissions []string           `json:"permissions"`
}

type UserResetPwdReq 

type UserResetPwdReq struct {
	g.Meta   `path:"/user/resetPwd" tags:"用户管理" method:"put" summary:"重置用户密码"`
	Id       uint64 `p:"userId" v:"required#用户id不能为空"`
	Password string `` /* 139-byte string literal not displayed */
}

UserResetPwdReq 重置用户密码状态参数

type UserResetPwdRes 

type UserResetPwdRes struct {
}

type UserSearchReq 

type UserSearchReq struct {
	g.Meta   `path:"/user/list" tags:"用户管理" method:"get" summary:"用户列表"`
	DeptId   string `p:"deptId"` //部门id
	Mobile   string `p:"mobile"`
	Status   string `p:"status"`
	KeyWords string `p:"keyWords"`
	commonApi.PageReq
}

UserSearchReq 用户搜索请求参数

type UserSearchRes 

type UserSearchRes struct {
	g.Meta   `mime:"application/json"`
	UserList []*model.SysUserRoleDeptRes `json:"userList"`
	commonApi.ListRes
}

type UserStatusReq 

type UserStatusReq struct {
	g.Meta     `path:"/user/setStatus" tags:"用户管理" method:"put" summary:"设置用户状态"`
	Id         uint64 `p:"userId" v:"required#用户id不能为空"`
	UserStatus uint   `p:"status" v:"required#用户状态不能为空"`
}

UserStatusReq 设置用户状态参数

type UserStatusRes 

type UserStatusRes struct {
}

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.