1

api/dto/AdminUser.go

@@ -0,0 +1,75 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+)
+
+// AdminUserDto 后台-用户表
+type AdminUserDto struct {
+	UserId     string          `json:"user_id"`     // 主键id
+	Access     string          `json:"access"`      // 账号
+	Password   string          `json:"password"`    // 密码
+	Salt       string          `json:"salt"`        // 密码掩码
+	NickName   string          `json:"nick_name"`   // 昵称
+	IsAdmin    int             `json:"is_admin"`    // 是否管理员（0:否 1:是）
+	Status     int             `json:"status"`      // 状态（1:正常 2:审核中 3:审核失败）
+	IsDeleted  int             `json:"is_deleted"`  // 是否被删除（0:否 1:是）
+	IsDisabled int             `json:"is_disabled"` // 是否被禁用（0:否 1:是）
+	Phone      string          `json:"phone"`       // 手机号
+	Avatar     string          `json:"avatar"`      // 头像
+	Sex        int             `json:"sex"`         // 性别（1:男 2:女）
+	Email      string          `json:"email"`       // 邮箱
+	CreatedAt  model.LocalTime `json:"created_at"`  // 创建时间
+	UpdatedAt  model.LocalTime `json:"updated_at"`  // 修改时间
+	Token      string          `json:"token"`       // token
+}
+
+// GetAdminUserListDto 列表
+func GetAdminUserListDto(m []*model.AdminUser) []*AdminUserDto {
+	// 处理返回值
+	responses := make([]*AdminUserDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &AdminUserDto{
+				UserId:     fmt.Sprintf("%d", v.UserId),
+				Access:     v.Access,
+				NickName:   v.NickName,
+				IsAdmin:    v.IsAdmin,
+				Status:     v.Status,
+				IsDeleted:  v.IsDeleted,
+				IsDisabled: v.IsDisabled,
+				Phone:      v.Phone,
+				Avatar:     utils.AddOssDomain(v.Avatar),
+				Sex:        v.Sex,
+				Email:      v.Email,
+				CreatedAt:  v.CreatedAt,
+				UpdatedAt:  v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+func GetAdminUserDto(m *model.AdminUser) *AdminUserDto {
+	return &AdminUserDto{
+		UserId:     fmt.Sprintf("%d", m.UserId),
+		Access:     m.Access,
+		Status:     m.Status,
+		IsDeleted:  m.IsDeleted,
+		IsDisabled: m.IsDisabled,
+		NickName:   m.NickName,
+		Phone:      m.Phone,
+		Avatar:     utils.AddOssDomain(m.Avatar),
+		Sex:        m.Sex,
+		Email:      m.Email,
+		CreatedAt:  m.CreatedAt,
+		UpdatedAt:  m.UpdatedAt,
+	}
+}

api/dto/BasicHospital.go

@@ -0,0 +1,67 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// BasicHospitalDto 基础数据-医院
+type BasicHospitalDto struct {
+	HospitalId    string          `json:"hospital_id"`    // 主键id
+	HospitalIden  string          `json:"hospital_iden"`  // app唯一标识
+	HospitalName  string          `json:"hospital_name"`  // 医院名称
+	HospitalLevel string          `json:"hospital_level"` // 医院等级
+	DoctorNumber  int             `json:"doctor_number"`  // 医生数量
+	Province      string          `json:"province"`       // 省份
+	City          string          `json:"city"`           // 城市
+	County        string          `json:"county"`         // 区县
+	Address       string          `json:"address"`        // 地址
+	CreatedAt     model.LocalTime `json:"created_at"`     // 创建时间
+	UpdatedAt     model.LocalTime `json:"updated_at"`     // 修改时间
+}
+
+// GetBasicHospitalListDto 列表
+func GetBasicHospitalListDto(m []*model.BasicHospital) []*BasicHospitalDto {
+	// 处理返回值
+	responses := make([]*BasicHospitalDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BasicHospitalDto{
+				HospitalId:    fmt.Sprintf("%d", v.HospitalId),
+				HospitalIden:  v.HospitalIden,
+				HospitalName:  v.HospitalName,
+				HospitalLevel: v.HospitalLevel,
+				DoctorNumber:  v.DoctorNumber,
+				Province:      v.Province,
+				City:          v.City,
+				County:        v.County,
+				Address:       v.Address,
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetBasicHospitalDto 详情
+func GetBasicHospitalDto(m *model.BasicHospital) *BasicHospitalDto {
+	return &BasicHospitalDto{
+		HospitalId:    fmt.Sprintf("%d", m.HospitalId),
+		HospitalIden:  m.HospitalIden,
+		HospitalName:  m.HospitalName,
+		HospitalLevel: m.HospitalLevel,
+		DoctorNumber:  m.DoctorNumber,
+		Province:      m.Province,
+		City:          m.City,
+		County:        m.County,
+		Address:       m.Address,
+		CreatedAt:     m.CreatedAt,
+		UpdatedAt:     m.UpdatedAt,
+	}
+}

api/dto/Case.go

@@ -0,0 +1,142 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CaseDto 病历表
+type CaseDto struct {
+	CaseId               string          `json:"case_id"`                 // 主键id
+	ProjectId            string          `json:"project_id"`              // 所属项目id
+	CaseStatus           int             `json:"case_status"`             // 病例状态（1:正常 2:禁用）
+	CaseName             string          `json:"case_name"`               // 病例名称
+	CaseAuthor           string          `json:"case_author"`             // 病例作者
+	SingleCaseScore      int             `json:"single_case_score"`       // 单个病例总积分
+	IssuedScore          int             `json:"issued_score"`            // 已发放积分
+	RemainingScore       int             `json:"remaining_score"`         // 剩余积分
+	JoinNum              int             `json:"join_num"`                // 多平台参加总人数
+	JoinWhiteNum         int             `json:"join_white_num"`          // 多平台白名单参加总人数
+	PlatformJoinNum      int             `json:"platform_join_num"`       // 肝胆相照平台参加总人数
+	PlatformJoinWhiteNum int             `json:"platform_join_white_num"` // 肝胆相照白名单参加总人数
+	MessageNum           int             `json:"message_num"`             // 多平台留言人数
+	CreatedAt            model.LocalTime `json:"created_at"`              // 创建时间
+	UpdatedAt            model.LocalTime `json:"updated_at"`              // 修改时间
+	CaseItem             []*CaseItemDto  `json:"case_item"`               // 病例明细
+}
+
+// GetCaseListDto 列表
+func GetCaseListDto(m []*model.Case) []*CaseDto {
+	// 处理返回值
+	responses := make([]*CaseDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseDto{
+				CaseId:       fmt.Sprintf("%d", v.CaseId),
+				ProjectId:    fmt.Sprintf("%d", v.ProjectId),
+				CaseStatus:   v.CaseStatus,
+				CaseName:     v.CaseName,
+				CaseAuthor:   v.CaseAuthor,
+				IssuedScore:  v.IssuedScore,
+				JoinNum:      v.JoinNum,
+				JoinWhiteNum: v.JoinWhiteNum,
+				MessageNum:   v.MessageNum,
+				CreatedAt:    v.CreatedAt,
+				UpdatedAt:    v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetCaseDto 详情
+func GetCaseDto(m *model.Case) *CaseDto {
+	return &CaseDto{
+		CaseId:       fmt.Sprintf("%d", m.CaseId),
+		ProjectId:    fmt.Sprintf("%d", m.ProjectId),
+		CaseStatus:   m.CaseStatus,
+		CaseName:     m.CaseName,
+		CaseAuthor:   m.CaseAuthor,
+		IssuedScore:  m.IssuedScore,
+		JoinNum:      m.JoinNum,
+		JoinWhiteNum: m.JoinWhiteNum,
+		MessageNum:   m.MessageNum,
+		CreatedAt:    m.CreatedAt,
+		UpdatedAt:    m.UpdatedAt,
+	}
+}
+
+// LoadCaseItem 加载数据-病例明细
+func (r *CaseDto) LoadCaseItem(m []*model.CaseItem) *CaseDto {
+	if len(m) > 0 {
+		r.CaseItem = GetCaseItemListDto(m)
+	}
+
+	return r
+}
+
+// LoadSingleCaseScore 加载数据-单个病例总积分
+func (r *CaseDto) LoadSingleCaseScore(m *model.ProjectPlatform) *CaseDto {
+	if m != nil {
+		r.SingleCaseScore = m.SingleCaseScore
+	}
+
+	return r
+}
+
+// LoadIssuedScore 加载数据-已发放积分
+func (r *CaseDto) LoadIssuedScore(m *model.CasePlatform) *CaseDto {
+	if m != nil {
+		r.IssuedScore = m.IssuedScore
+	}
+
+	return r
+}
+
+// LoadRemainingScore 加载数据-剩余积分
+func (r *CaseDto) LoadRemainingScore(m int) *CaseDto {
+	r.RemainingScore = m
+
+	return r
+}
+
+// LoadPlatformJoinNum 加载数据-参与人数-肝胆相照平台
+func (r *CaseDto) LoadPlatformJoinNum(m *model.CasePlatform) *CaseDto {
+	if m != nil {
+		r.PlatformJoinNum = m.JoinNum
+	}
+
+	return r
+}
+
+// LoadPlatformJoinWhiteNum 加载数据-白名单参与人数-肝胆相照平台
+func (r *CaseDto) LoadPlatformJoinWhiteNum(m *model.CasePlatform) *CaseDto {
+	if m != nil {
+		r.PlatformJoinWhiteNum = m.JoinWhiteNum
+	}
+
+	return r
+}
+
+// LoadJoinNum 加载数据-参与人数-全平台
+func (r *CaseDto) LoadJoinNum(m *model.Case) *CaseDto {
+	if m != nil {
+		r.JoinNum = m.JoinNum
+	}
+
+	return r
+}
+
+// LoadJoinWhiteNum 加载数据-白名单参与人数-全平台
+func (r *CaseDto) LoadJoinWhiteNum(m *model.Case) *CaseDto {
+	if m != nil {
+		r.JoinWhiteNum = m.JoinWhiteNum
+	}
+
+	return r
+}

api/dto/CaseComment.go

@@ -0,0 +1,136 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+)
+
+// CaseCommentDto 病历表-评论
+type CaseCommentDto struct {
+	CommentId          string          `json:"comment_id"`            // 主键id
+	CaseId             string          `json:"case_id"`               // 所属病例id
+	PlatformId         string          `json:"platform_id"`           // 来源平台id
+	ParentId           string          `json:"parent_id,omitempty"`   // 父级id，一级评论为null
+	RootId             string          `json:"root_id,omitempty"`     // 根评论id，一级评论时为null。其余为一级评论id
+	Level              int             `json:"level"`                 // 级别（1:留言 2:回复 3:评论）
+	UserId             string          `json:"user_id"`               // 用户id
+	Status             int             `json:"status"`                // 评论状态（0:禁用 1:正常）
+	IsSensitive        int             `json:"is_sensitive"`          // 是否存在敏感词（0:否 1:是）
+	IsHighQuality      int             `json:"is_high_quality"`       // 是否优质留言（0:否 1:是）
+	IsGrantHighQuality int             `json:"is_grant_high_quality"` // 优质留言积分是否已发放（0:否 1:是）
+	LikeNum            int             `json:"like_num"`              // 点赞数量
+	Content            string          `json:"content"`               // 评论内容
+	ContentWord        string          `json:"content_word"`          // 评论内容(原版)
+	CreatedAt          model.LocalTime `json:"created_at"`            // 创建时间
+	UpdatedAt          model.LocalTime `json:"updated_at"`            // 修改时间
+	Area               string          `json:"area"`                  // 省份
+	HospitalName       string          `json:"hospital_name"`         // 医院
+	DepartmentName     string          `json:"department_name"`       // 科室
+	Title              string          `json:"title"`                 // 职称
+	UserName           string          `json:"user_name"`             // 用户名称
+}
+
+// GetCaseCommentListDto 列表
+func GetCaseCommentListDto(m []*model.CaseComment) []*CaseCommentDto {
+	// 处理返回值
+	responses := make([]*CaseCommentDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseCommentDto{
+				CommentId:          fmt.Sprintf("%d", v.CommentId),
+				CaseId:             fmt.Sprintf("%d", v.CaseId),
+				PlatformId:         fmt.Sprintf("%d", v.PlatformId),
+				Level:              v.Level,
+				UserId:             fmt.Sprintf("%d", v.UserId),
+				Status:             v.Status,
+				IsSensitive:        v.IsSensitive,
+				IsHighQuality:      v.IsHighQuality,
+				IsGrantHighQuality: v.IsGrantHighQuality,
+				LikeNum:            v.LikeNum,
+				Content:            v.Content,
+				ContentWord:        v.ContentWord,
+				CreatedAt:          v.CreatedAt,
+				UpdatedAt:          v.UpdatedAt,
+			}
+
+			if v.ParentId != 0 {
+				response.ParentId = fmt.Sprintf("%d", v.ParentId)
+			}
+
+			if v.RootId != 0 {
+				response.RootId = fmt.Sprintf("%d", v.RootId)
+			}
+
+			// 加载数据-用户名称
+			if v.User != nil {
+				// 加载数据-科室
+				response = response.LoadDepartmentName(v.User)
+
+				// 加载数据-职称
+				response = response.LoadTitle(v.User)
+
+				// 加载数据-用户名称
+				response = response.LoadUserName(v.User)
+
+				// 加载数据-省份
+				if v.User.Hospital != nil {
+					response = response.LoadArea(v.User.Hospital)
+
+					response = response.LoadHospitalName(v.User.Hospital)
+				}
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadArea 加载数据-省份
+func (r *CaseCommentDto) LoadArea(m *model.BasicHospital) *CaseCommentDto {
+	if m != nil {
+		r.Area = m.Province
+	}
+
+	return r
+}
+
+// LoadDepartmentName 加载数据-科室
+func (r *CaseCommentDto) LoadDepartmentName(m *model.User) *CaseCommentDto {
+	if m != nil {
+		r.DepartmentName = m.DepartmentName
+	}
+
+	return r
+}
+
+// LoadTitle 加载数据-职称
+func (r *CaseCommentDto) LoadTitle(m *model.User) *CaseCommentDto {
+	if m != nil {
+		r.Title = utils.DoctorTitleToString(m.Title)
+	}
+
+	return r
+}
+
+// LoadUserName 加载数据-用户名称
+func (r *CaseCommentDto) LoadUserName(m *model.User) *CaseCommentDto {
+	if m != nil {
+		r.UserName = m.UserName
+	}
+
+	return r
+}
+
+// LoadHospitalName 加载数据-医院名称
+func (r *CaseCommentDto) LoadHospitalName(m *model.BasicHospital) *CaseCommentDto {
+	if m != nil {
+		r.HospitalName = m.HospitalName
+	}
+
+	return r
+}

api/dto/CaseItem.go

@@ -0,0 +1,59 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CaseItemDto 病历表-明细
+type CaseItemDto struct {
+	CaseItemId       string                 `json:"case_item_id"`       // 主键id
+	CaseId           string                 `json:"case_id"`            // 所属病例id
+	Page             int                    `json:"page"`               // 页码
+	CreatedAt        model.LocalTime        `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime        `json:"updated_at"`         // 修改时间
+	CaseItemQuestion []*CaseItemQuestionDto `json:"case_item_question"` // 病例明细-题目
+	CaseItemModel    []*CaseItemModelDto    `json:"case_item_model"`    // 病例明细-模块
+}
+
+// GetCaseItemListDto 列表
+func GetCaseItemListDto(m []*model.CaseItem) []*CaseItemDto {
+	// 处理返回值
+	responses := make([]*CaseItemDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseItemDto{
+				CaseItemId:    fmt.Sprintf("%d", v.CaseItemId),
+				CaseId:        fmt.Sprintf("%d", v.CaseId),
+				Page:          v.Page,
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+				CaseItemModel: []*CaseItemModelDto{},
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadCaseItemQuestion 加载数据-病例明细-题目
+func (r *CaseItemDto) LoadCaseItemQuestion(m []*model.CaseItemQuestion) *CaseItemDto {
+	if len(m) > 0 {
+		r.CaseItemQuestion = GetCaseItemQuestionListDto(m)
+	}
+
+	return r
+}
+
+// LoadCaseItemModel 加载数据-病例明细-模块
+func (r *CaseItemDto) LoadCaseItemModel(m []*model.CaseItemModel) *CaseItemDto {
+	if len(m) > 0 {
+		r.CaseItemModel = GetCaseItemModelListDto(m)
+	}
+
+	return r
+}

api/dto/CaseItemModel.go

@@ -0,0 +1,40 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CaseItemModelDto 病历表-明细
+type CaseItemModelDto struct {
+	CaseItemModelId string          `json:"case_item_model_id"` // 主键id
+	CaseItemId      string          `json:"case_item_id"`       // 明细id
+	ModelName       string          `json:"model_name"`         // 模型名称
+	Content         string          `json:"content"`            // 详情内容
+	CreatedAt       model.LocalTime `json:"created_at"`         // 创建时间
+	UpdatedAt       model.LocalTime `json:"updated_at"`         // 修改时间
+}
+
+// GetCaseItemModelListDto 列表
+func GetCaseItemModelListDto(m []*model.CaseItemModel) []*CaseItemModelDto {
+	// 处理返回值
+	responses := make([]*CaseItemModelDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseItemModelDto{
+				CaseItemModelId: fmt.Sprintf("%d", v.CaseItemModelId),
+				CaseItemId:      fmt.Sprintf("%d", v.CaseItemId),
+				ModelName:       v.ModelName,
+				Content:         v.Content,
+				CreatedAt:       v.CreatedAt,
+				UpdatedAt:       v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/CaseItemQuestion.go

@@ -0,0 +1,61 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CaseItemQuestionDto 病历表-明细-题目
+type CaseItemQuestionDto struct {
+	QuestionId             string                       `json:"question_id"`               // 主键id
+	CaseItemId             string                       `json:"case_item_id"`              // 病例明细id
+	QuestionName           string                       `json:"question_name"`             // 题目名称
+	QuestionType           int                          `json:"question_type"`             // 题目类型(1:单选 2:多选 3:问答 4:判断)
+	QuestionAnswer         string                       `json:"question_answer"`           // 答案
+	IsRightNext            int                          `json:"is_right_next"`             // 是否答对后允许下一步（0:否 1:是）
+	ErrorTips              string                       `json:"error_tips"`                // 答错提示
+	CreatedAt              model.LocalTime              `json:"created_at"`                // 创建时间
+	UpdatedAt              model.LocalTime              `json:"updated_at"`                // 修改时间
+	CaseItemQuestionOption []*CaseItemQuestionOptionDto `json:"case_item_question_option"` // 题目选项列表
+}
+
+// GetCaseItemQuestionListDto 列表
+func GetCaseItemQuestionListDto(m []*model.CaseItemQuestion) []*CaseItemQuestionDto {
+	// 处理返回值
+	responses := make([]*CaseItemQuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseItemQuestionDto{
+				QuestionId:     fmt.Sprintf("%d", v.QuestionId),
+				CaseItemId:     fmt.Sprintf("%d", v.CaseItemId),
+				QuestionName:   v.QuestionName,
+				QuestionType:   v.QuestionType,
+				QuestionAnswer: v.QuestionAnswer,
+				IsRightNext:    v.IsRightNext,
+				ErrorTips:      v.ErrorTips,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 加载数据-病例明细-题目-选项
+			if v.CaseItemQuestionOption != nil {
+				response = response.LoadCaseItemQuestionOption(v.CaseItemQuestionOption)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadCaseItemQuestionOption 加载数据-病例明细-题目-选项
+func (r *CaseItemQuestionDto) LoadCaseItemQuestionOption(m []*model.CaseItemQuestionOption) *CaseItemQuestionDto {
+	if len(m) > 0 {
+		r.CaseItemQuestionOption = GetCaseItemQuestionOptionListDto(m)
+	}
+
+	return r
+}

api/dto/CaseItemQuestionOption.go

@@ -0,0 +1,38 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CaseItemQuestionOptionDto 病历表-明细-题目-选项
+type CaseItemQuestionOptionDto struct {
+	OptionId    string          `json:"option_id"`    //主键id
+	QuestionId  string          `json:"question_id"`  // 题目id
+	OptionValue string          `json:"option_value"` // 选项内容
+	CreatedAt   model.LocalTime `json:"created_at"`   // 创建时间
+	UpdatedAt   model.LocalTime `json:"updated_at"`   // 修改时间
+}
+
+// GetCaseItemQuestionOptionListDto 列表
+func GetCaseItemQuestionOptionListDto(m []*model.CaseItemQuestionOption) []*CaseItemQuestionOptionDto {
+	// 处理返回值
+	responses := make([]*CaseItemQuestionOptionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseItemQuestionOptionDto{
+				OptionId:    fmt.Sprintf("%d", v.OptionId),
+				QuestionId:  fmt.Sprintf("%d", v.QuestionId),
+				OptionValue: v.OptionValue,
+				CreatedAt:   v.CreatedAt,
+				UpdatedAt:   v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/CasePlatform.go

@@ -0,0 +1,78 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// CasePlatformDto 统计数据-病例-平台
+type CasePlatformDto struct {
+	CasePlatformId  string          `json:"case_platform_id"`  // 主键id
+	CaseId          string          `json:"case_id"`           // 所属病例id
+	PlatformId      string          `json:"platform_id"`       // 用户所属平台id
+	SingleCaseScore int             `json:"single_case_score"` // 单个病例总积分
+	IssuedScore     int             `json:"issued_score"`      // 已发放积分
+	RemainingScore  int             `json:"remaining_score"`   // 剩余积分
+	JoinNum         int             `json:"join_num"`          // 参加人数
+	JoinWhiteNum    int             `json:"join_white_num"`    // 白名单参加人数
+	MessageNum      int             `json:"message_num"`       // 留言人数
+	CreatedAt       model.LocalTime `json:"created_at"`        // 创建时间
+	UpdatedAt       model.LocalTime `json:"updated_at"`        // 修改时间
+	PlatformName    string          `json:"platform_name"`     // 平台名称
+}
+
+// GetCasePlatformListDto 列表
+func GetCasePlatformListDto(m []*model.CasePlatform) []*CasePlatformDto {
+	// 处理返回值
+	responses := make([]*CasePlatformDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CasePlatformDto{
+				CasePlatformId: fmt.Sprintf("%d", v.CasePlatformId),
+				CaseId:         fmt.Sprintf("%d", v.CaseId),
+				PlatformId:     fmt.Sprintf("%d", v.PlatformId),
+				IssuedScore:    v.IssuedScore,
+				JoinNum:        v.JoinNum,
+				JoinWhiteNum:   v.JoinWhiteNum,
+				MessageNum:     v.MessageNum,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			if v.Platform != nil {
+				response = response.LoadPlatFormName(v.Platform)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadPlatFormName 加载数据-平台名称
+func (r *CasePlatformDto) LoadPlatFormName(m *model.Platform) *CasePlatformDto {
+	if m != nil {
+		r.PlatformName = m.PlatformName
+	}
+
+	return r
+}
+
+// LoadSingleCaseScore 加载数据-单个病例总积分
+func (r *CasePlatformDto) LoadSingleCaseScore(m *model.ProjectPlatform) *CasePlatformDto {
+	if m != nil {
+		r.SingleCaseScore = m.SingleCaseScore
+	}
+
+	return r
+}
+
+// LoadRemainingScore 加载数据-剩余积分
+func (r *CasePlatformDto) LoadRemainingScore(m int) *CasePlatformDto {
+	r.RemainingScore = m
+
+	return r
+}

api/dto/CaseUser.go

@@ -0,0 +1,134 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+)
+
+// CaseUserDto 统计数据-病例-用户
+type CaseUserDto struct {
+	CaseUserId     string          `json:"case_user_id"`    // 主键id
+	CaseId         string          `json:"case_id"`         // 所属病例id
+	PlatformId     string          `json:"platform_id"`     // 用户所属平台id
+	UserId         string          `json:"user_id"`         // 用户id
+	ShareUserIden  string          `json:"share_user_iden"` // 分享人标识
+	ReadDuration   int             `json:"read_duration"`   // 阅读时长（秒）
+	TotalScore     int             `json:"total_score"`     // 单个病例领取总积分
+	StartTime      model.LocalTime `json:"start_time"`      // 开始参与时间
+	EndTime        model.LocalTime `json:"end_time"`        // 结束参与时间
+	CreatedAt      model.LocalTime `json:"created_at"`      // 创建时间
+	UpdatedAt      model.LocalTime `json:"updated_at"`      // 修改时间
+	PlatformName   string          `json:"platform_name"`   // 平台名称
+	Area           string          `json:"area"`            // 省份
+	HospitalName   string          `json:"hospital_name"`   // 医院
+	DepartmentName string          `json:"department_name"` // 科室
+	Title          string          `json:"title"`           // 职称
+	UserName       string          `json:"user_name"`       // 用户名称
+}
+
+// GetCaseUserListDto 列表
+func GetCaseUserListDto(m []*model.CaseUser) []*CaseUserDto {
+	// 处理返回值
+	responses := make([]*CaseUserDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CaseUserDto{
+				CaseUserId:    fmt.Sprintf("%d", v.CaseUserId),
+				CaseId:        fmt.Sprintf("%d", v.CaseId),
+				PlatformId:    fmt.Sprintf("%d", v.PlatformId),
+				UserId:        fmt.Sprintf("%d", v.UserId),
+				ShareUserIden: v.ShareUserIden,
+				ReadDuration:  v.ReadDuration,
+				TotalScore:    v.TotalScore,
+				StartTime:     v.StartTime,
+				EndTime:       v.EndTime,
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+			}
+
+			// 加载数据-平台名称
+			if v.Platform != nil {
+				response = response.LoadPlatFormName(v.Platform)
+			}
+
+			if v.User != nil {
+				// 加载数据-科室
+				response = response.LoadDepartmentName(v.User)
+
+				// 加载数据-职称
+				response = response.LoadTitle(v.User)
+
+				// 加载数据-用户名称
+				response = response.LoadUserName(v.User)
+
+				// 加载数据-省份
+				if v.User.Hospital != nil {
+					response = response.LoadArea(v.User.Hospital)
+
+					response = response.LoadHospitalName(v.User.Hospital)
+				}
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadPlatFormName 加载数据-平台名称
+func (r *CaseUserDto) LoadPlatFormName(m *model.Platform) *CaseUserDto {
+	if m != nil {
+		r.PlatformName = m.PlatformName
+	}
+
+	return r
+}
+
+// LoadArea 加载数据-省份
+func (r *CaseUserDto) LoadArea(m *model.BasicHospital) *CaseUserDto {
+	if m != nil {
+		r.Area = m.Province
+	}
+
+	return r
+}
+
+// LoadDepartmentName 加载数据-科室
+func (r *CaseUserDto) LoadDepartmentName(m *model.User) *CaseUserDto {
+	if m != nil {
+		r.DepartmentName = m.DepartmentName
+	}
+
+	return r
+}
+
+// LoadTitle 加载数据-职称
+func (r *CaseUserDto) LoadTitle(m *model.User) *CaseUserDto {
+	if m != nil {
+		r.Title = utils.DoctorTitleToString(m.Title)
+	}
+
+	return r
+}
+
+// LoadUserName 加载数据-用户名称
+func (r *CaseUserDto) LoadUserName(m *model.User) *CaseUserDto {
+	if m != nil {
+		r.UserName = m.UserName
+	}
+
+	return r
+}
+
+// LoadHospitalName 加载数据-医院名称
+func (r *CaseUserDto) LoadHospitalName(m *model.BasicHospital) *CaseUserDto {
+	if m != nil {
+		r.HospitalName = m.HospitalName
+	}
+
+	return r
+}

api/dto/Platform.go

@@ -0,0 +1,55 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// PlatformDto 平台表
+type PlatformDto struct {
+	PlatformId     string          `json:"platform_id"`     // 主键id
+	PlatformName   string          `json:"platform_name"`   // 平台名称
+	PlatformStatus int             `json:"platform_status"` // 平台状态（1:正常 2:禁用）
+	PlatformKey    string          `json:"platform_key"`    // 平台标识（用于鉴权）
+	PlatformSecret string          `json:"platform_secret"` // 平台密钥（用于鉴权）
+	CreatedAt      model.LocalTime `json:"created_at"`      // 创建时间
+	UpdatedAt      model.LocalTime `json:"updated_at"`      // 修改时间
+}
+
+// GetPlatformListDto 列表
+func GetPlatformListDto(m []*model.Platform) []*PlatformDto {
+	// 处理返回值
+	responses := make([]*PlatformDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &PlatformDto{
+				PlatformId:     fmt.Sprintf("%d", v.PlatformId),
+				PlatformStatus: v.PlatformStatus,
+				PlatformName:   v.PlatformName,
+				PlatformKey:    v.PlatformKey,
+				PlatformSecret: v.PlatformSecret,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetPlatformDto 详情
+func GetPlatformDto(m *model.Platform) *PlatformDto {
+	return &PlatformDto{
+		PlatformId:     fmt.Sprintf("%d", m.PlatformId),
+		PlatformStatus: m.PlatformStatus,
+		PlatformName:   m.PlatformName,
+		PlatformKey:    m.PlatformKey,
+		PlatformSecret: m.PlatformSecret,
+		CreatedAt:      m.CreatedAt,
+		UpdatedAt:      m.UpdatedAt,
+	}
+}

api/dto/Project.go

@@ -0,0 +1,99 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+	"time"
+)
+
+type ProjectDto struct {
+	ProjectId         string          `json:"project_id"`           // 主键id
+	ProjectName       string          `json:"project_name"`         // 项目名称
+	ProjectStatus     int             `json:"project_status"`       // 项目状态（0:无效 1:正常）
+	ProjectImage      string          `json:"project_image"`        // 项目背景图
+	CreatedAt         model.LocalTime `json:"created_at"`           // 创建时间
+	UpdatedAt         model.LocalTime `json:"updated_at"`           // 修改时间
+	CaseCount         int             `json:"case_count"`           // 关联病例数量
+	ProjectPlatform   int             `json:"project_platform"`     // 关联平台数量
+	LastCaseUpdatedAt model.LocalTime `json:"last_case_updated_at"` // 最后病例修改时间
+}
+
+// GetProjectListDto 列表
+func GetProjectListDto(m []*model.Project) []*ProjectDto {
+	// 处理返回值
+	responses := make([]*ProjectDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectDto{
+				ProjectId:     fmt.Sprintf("%d", v.ProjectId),
+				ProjectName:   v.ProjectName,
+				ProjectStatus: v.ProjectStatus,
+				ProjectImage:  utils.AddOssDomain(v.ProjectImage),
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+			}
+
+			// 加载关联病例数量
+			response = response.LoadCaseCount(v.Case)
+
+			// 加载关联平台数量
+			response = response.LoadProjectPlatform(v.ProjectPlatform)
+
+			// 加载最后病例修改时间
+			response = response.LoadLastCaseUpdatedAt(v.ProjectPlatform)
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetProjectDto 详情
+func GetProjectDto(m *model.Project) *ProjectDto {
+	return &ProjectDto{
+		ProjectId:     fmt.Sprintf("%d", m.ProjectId),
+		ProjectName:   m.ProjectName,
+		ProjectStatus: m.ProjectStatus,
+		ProjectImage:  utils.AddOssDomain(m.ProjectImage),
+		CreatedAt:     m.CreatedAt,
+		UpdatedAt:     m.UpdatedAt,
+	}
+}
+
+// LoadCaseCount 加载关联病例数量
+func (r *ProjectDto) LoadCaseCount(m []*model.Case) *ProjectDto {
+	if len(m) > 0 {
+		r.CaseCount = len(m)
+	}
+	return r
+}
+
+// LoadProjectPlatform 加载关联平台数量
+func (r *ProjectDto) LoadProjectPlatform(m []*model.ProjectPlatform) *ProjectDto {
+	if len(m) > 0 {
+		r.ProjectPlatform = len(m)
+	}
+	return r
+}
+
+// LoadLastCaseUpdatedAt 加载最后病例修改时间
+func (r *ProjectDto) LoadLastCaseUpdatedAt(m []*model.ProjectPlatform) *ProjectDto {
+	if len(m) > 0 {
+		// 初始化最新时间为第一条记录的时间
+		latestTime := m[0].UpdatedAt
+
+		// 遍历所有记录找出最新的更新时间
+		for _, v := range m {
+			if time.Time(v.UpdatedAt).After(time.Time(latestTime)) {
+				latestTime = v.UpdatedAt
+			}
+		}
+
+		r.LastCaseUpdatedAt = latestTime
+	}
+	return r
+}

api/dto/ProjectPlatform.go

@@ -0,0 +1,94 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDto 项目表-关联平台
+type ProjectPlatformDto struct {
+	ProjectPlatformId   string          `json:"project_platform_id"`    // 主键id
+	PlatformId          string          `json:"platform_id"`            // 主键id
+	ProjectId           string          `json:"project_id"`             // 项目id
+	Status              int             `json:"status"`                 // 状态（1:正常 2:禁用）
+	IsWelfare           int             `json:"is_welfare"`             // 是否开启福利（0:否 1:是）
+	ReadDuration        int             `json:"read_duration"`          // 阅读时长（秒）
+	SingleCaseScore     int             `json:"single_case_score"`      // 单个病例总积分
+	CompleteRead        int             `json:"complete_read"`          // 完成阅读积分
+	CompleteReadTime    int             `json:"complete_read_time"`     // 完成阅读时间积分
+	FirstHighQuality    int             `json:"first_high_quality"`     // 首次优质留言积分
+	OnceMoreHighQuality int             `json:"once_more_high_quality"` // 再次优质留言积分
+	IsWhite             int             `json:"is_white"`               // 是否开启白名单（0:否 1:是）
+	WhiteType           int             `json:"white_type"`             // 白名单类型（1:医院 2:医生 3:动态）
+	CreatedAt           model.LocalTime `json:"created_at"`             // 创建时间
+	UpdatedAt           model.LocalTime `json:"updated_at"`             // 修改时间
+	PlatformName        string          `json:"platform_name"`          // 平台名称
+}
+
+// GetProjectPlatformListDto 列表
+func GetProjectPlatformListDto(m []*model.ProjectPlatform) []*ProjectPlatformDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformDto{
+				ProjectPlatformId:   fmt.Sprintf("%d", v.ProjectPlatformId),
+				PlatformId:          fmt.Sprintf("%d", v.PlatformId),
+				ProjectId:           fmt.Sprintf("%d", v.ProjectId),
+				Status:              v.Status,
+				IsWelfare:           v.IsWelfare,
+				ReadDuration:        v.ReadDuration,
+				SingleCaseScore:     v.SingleCaseScore,
+				CompleteRead:        v.CompleteRead,
+				CompleteReadTime:    v.CompleteReadTime,
+				FirstHighQuality:    v.FirstHighQuality,
+				OnceMoreHighQuality: v.OnceMoreHighQuality,
+				IsWhite:             v.IsWhite,
+				WhiteType:           v.WhiteType,
+				CreatedAt:           v.CreatedAt,
+				UpdatedAt:           v.UpdatedAt,
+			}
+
+			// 加载数据-平台名称
+			if v.Platform != nil {
+				response = response.LoadPlatFormName(v.Platform)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetProjectPlatformDto 详情
+func GetProjectPlatformDto(m *model.ProjectPlatform) *ProjectPlatformDto {
+	return &ProjectPlatformDto{
+		ProjectPlatformId:   fmt.Sprintf("%d", m.ProjectPlatformId),
+		PlatformId:          fmt.Sprintf("%d", m.PlatformId),
+		ProjectId:           fmt.Sprintf("%d", m.ProjectId),
+		Status:              m.Status,
+		IsWelfare:           m.IsWelfare,
+		ReadDuration:        m.ReadDuration,
+		SingleCaseScore:     m.SingleCaseScore,
+		CompleteRead:        m.CompleteRead,
+		CompleteReadTime:    m.CompleteReadTime,
+		FirstHighQuality:    m.FirstHighQuality,
+		OnceMoreHighQuality: m.OnceMoreHighQuality,
+		IsWhite:             m.IsWhite,
+		WhiteType:           m.WhiteType,
+		CreatedAt:           m.CreatedAt,
+		UpdatedAt:           m.UpdatedAt,
+	}
+}
+
+// LoadPlatFormName 加载数据-平台名称
+func (r *ProjectPlatformDto) LoadPlatFormName(m *model.Platform) *ProjectPlatformDto {
+	if m != nil {
+		r.PlatformName = m.PlatformName
+	}
+
+	return r
+}

api/dto/ProjectPlatformDoctor.go

@@ -0,0 +1,53 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDoctorDto 关联平台-白名单-医生
+type ProjectPlatformDoctorDto struct {
+	WhiteDoctorId     string          `json:"white_doctor_id"`     // 主键id
+	ProjectPlatformId string          `json:"project_platform_id"` // 关联id
+	UserId            string          `json:"user_id"`             // 关联用户id
+	Status            int             `json:"status"`              // 状态（1:正常 2:禁用）
+	CreatedAt         model.LocalTime `json:"created_at"`          // 创建时间
+	UpdatedAt         model.LocalTime `json:"updated_at"`          // 修改时间
+	User              *UserDto        `json:"user"`                //
+}
+
+// GetProjectPlatformDoctorListDto 列表
+func GetProjectPlatformDoctorListDto(m []*model.ProjectPlatformDoctor) []*ProjectPlatformDoctorDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformDoctorDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformDoctorDto{
+				WhiteDoctorId:     fmt.Sprintf("%d", v.WhiteDoctorId),
+				ProjectPlatformId: fmt.Sprintf("%d", v.ProjectPlatformId),
+				UserId:            fmt.Sprintf("%d", v.UserId),
+				Status:            v.Status,
+				CreatedAt:         v.CreatedAt,
+				UpdatedAt:         v.UpdatedAt,
+			}
+
+			// 加载数据-医院列表
+			response = response.LoadUser(v.User)
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadUser 加载数据-用户列表
+func (r *ProjectPlatformDoctorDto) LoadUser(m *model.User) *ProjectPlatformDoctorDto {
+	if m != nil {
+		r.User = GetUserDto(m)
+	}
+
+	return r
+}

api/dto/ProjectPlatformDynamic.go

@@ -0,0 +1,50 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDynamicDto 关联平台-白名单-动态
+type ProjectPlatformDynamicDto struct {
+	WhiteDynamicId                string                           `gorm:"column:white_dynamic_id;type:bigint(19);primary_key;comment:主键id" json:"white_dynamic_id"`
+	ProjectPlatformId             string                           `json:"project_platform_id"` // 关联id
+	DynamicType                   string                           `gorm:"column:dynamic_type;type:varchar(50);comment:动态类型（area:省份 level:医院等级 title:职称 department:科室 url:地址栏 类型间以-链接）" json:"dynamic_type"`
+	Status                        int                              `gorm:"column:status;type:tinyint(1);comment:状态（1:正常 2:禁用）" json:"status"`
+	CreatedAt                     model.LocalTime                  `json:"created_at"` // 创建时间
+	UpdatedAt                     model.LocalTime                  `json:"updated_at"` // 修改时间
+	ProjectPlatformDynamicItemDto []*ProjectPlatformDynamicItemDto `json:"project_platform_dynamic_item"`
+}
+
+// GetProjectPlatformDynamicListDto 列表
+func GetProjectPlatformDynamicListDto(m []*model.ProjectPlatformDynamic) []*ProjectPlatformDynamicDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformDynamicDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformDynamicDto{
+				WhiteDynamicId:    fmt.Sprintf("%d", v.WhiteDynamicId),
+				ProjectPlatformId: fmt.Sprintf("%d", v.ProjectPlatformId),
+				DynamicType:       v.DynamicType,
+				Status:            v.Status,
+				CreatedAt:         v.CreatedAt,
+				UpdatedAt:         v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadItem 加载数据-明细
+func (r *ProjectPlatformDynamicDto) LoadItem(m []*model.ProjectPlatformDynamicItem) *ProjectPlatformDynamicDto {
+	if len(m) > 0 {
+		r.ProjectPlatformDynamicItemDto = GetProjectPlatformDynamicItemListDto(m)
+	}
+
+	return r
+}

api/dto/ProjectPlatformDynamicItem.go

@@ -0,0 +1,38 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDynamicItemDto 关联平台-白名单-动态-明细
+type ProjectPlatformDynamicItemDto struct {
+	ItemId         string          `gorm:"column:item_id;type:bigint(19);primary_key;comment:主键id" json:"item_id"`
+	WhiteDynamicId string          `gorm:"column:white_dynamic_id;type:bigint(19);comment:关联动态白名单id;NOT NULL" json:"white_dynamic_id"`
+	ItemValue      string          `gorm:"column:item_value;type:varchar(255);comment:明细值（area:省份 level:医院等级 title:职称 department:科室 url:地址栏 类型间以-链接）" json:"item_value"`
+	CreatedAt      model.LocalTime `json:"created_at"` // 创建时间
+	UpdatedAt      model.LocalTime `json:"updated_at"` // 修改时间
+}
+
+// GetProjectPlatformDynamicItemListDto 列表
+func GetProjectPlatformDynamicItemListDto(m []*model.ProjectPlatformDynamicItem) []*ProjectPlatformDynamicItemDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformDynamicItemDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformDynamicItemDto{
+				ItemId:         fmt.Sprintf("%d", v.ItemId),
+				WhiteDynamicId: fmt.Sprintf("%d", v.WhiteDynamicId),
+				ItemValue:      v.ItemValue,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/ProjectPlatformHospital.go

@@ -0,0 +1,53 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformHospitalDto 关联平台-白名单-医院
+type ProjectPlatformHospitalDto struct {
+	WhiteHospitalId   string            `json:"white_hospital_id"`   // 主键id
+	ProjectPlatformId string            `json:"project_platform_id"` // 关联id
+	HospitalId        string            `json:"hospital_id"`         // 医院id
+	Status            int               `json:"status"`              // 状态（1:正常 2:禁用）
+	CreatedAt         model.LocalTime   `json:"created_at"`          // 创建时间
+	UpdatedAt         model.LocalTime   `json:"updated_at"`          // 修改时间
+	BasicHospital     *BasicHospitalDto `json:"basic_hospital"`      // 基础数据-医院
+}
+
+// GetProjectPlatformHospitalListDto 列表
+func GetProjectPlatformHospitalListDto(m []*model.ProjectPlatformHospital) []*ProjectPlatformHospitalDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformHospitalDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformHospitalDto{
+				WhiteHospitalId:   fmt.Sprintf("%d", v.WhiteHospitalId),
+				ProjectPlatformId: fmt.Sprintf("%d", v.ProjectPlatformId),
+				HospitalId:        fmt.Sprintf("%d", v.HospitalId),
+				Status:            v.Status,
+				CreatedAt:         v.CreatedAt,
+				UpdatedAt:         v.UpdatedAt,
+			}
+
+			// 加载数据-医院
+			response = response.LoadBasicHospital(v.BasicHospital)
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadBasicHospital 加载数据-医院
+func (r *ProjectPlatformHospitalDto) LoadBasicHospital(m *model.BasicHospital) *ProjectPlatformHospitalDto {
+	if m != nil {
+		r.BasicHospital = GetBasicHospitalDto(m)
+	}
+
+	return r
+}

api/dto/Public.go

@@ -0,0 +1,30 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+)
+
+// LoginDto 登陆
+type LoginDto struct {
+	UserId   string `json:"user_id"`   // 用户id
+	NickName string `json:"nick_name"` // 用户名称
+	Avatar   string `json:"avatar"`    // 头像
+	Token    string `json:"token"`     // token
+}
+
+// AdminLoginDto 微信登陆
+func AdminLoginDto(m *model.AdminUser) *LoginDto {
+	return &LoginDto{
+		UserId:   fmt.Sprintf("%d", m.UserId),
+		NickName: m.NickName,
+		Avatar:   utils.AddOssDomain(m.Avatar),
+	}
+}
+
+// LoadToken 加载token
+func (r *LoginDto) LoadToken(token string) *LoginDto {
+	r.Token = token
+	return r
+}

api/dto/User.go

@@ -0,0 +1,80 @@
+package dto
+
+import (
+	"case-admin-api/api/model"
+	"case-admin-api/utils"
+	"fmt"
+)
+
+// UserDto 用户表
+type UserDto struct {
+	UserId         string          `json:"user_id"`         // 主键id
+	UserIden       string          `json:"user_iden"`       // app唯一标识
+	UserName       string          `json:"user_name"`       // 用户名称
+	UserMobile     string          `json:"user_mobile"`     // 手机号
+	Status         int             `json:"status"`          // 状态（0:禁用 1:正常 2:删除）
+	RegisterSource int             `json:"register_source"` // 注册来源（1:未知 2:app用户 3:佳动例）
+	OpenId         string          `json:"open_id"`         // 用户微信标识
+	UnionId        string          `json:"union_id"`        // 微信开放平台标识
+	Sex            int             `json:"sex"`             // 性别（0:未知 1:男 2:女）
+	Avatar         string          `json:"avatar"`          // 头像
+	Title          int             `json:"title"`           // 医生职称（1:主任医师 2:主任中医师 3:副主任医师 4:副主任中医师 5:主治医师 6:住院医师）
+	DepartmentName string          `json:"department_name"` // 科室名称
+	HospitalId     string          `json:"hospital_id"`     // 所属医院id
+	CreatedAt      model.LocalTime `json:"created_at"`      // 创建时间
+	UpdatedAt      model.LocalTime `json:"updated_at"`      // 修改时间
+}
+
+// GetUserListDto 列表
+func GetUserListDto(m []*model.User) []*UserDto {
+	// 处理返回值
+	responses := make([]*UserDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &UserDto{
+				UserId:         fmt.Sprintf("%d", v.UserId),
+				UserIden:       v.UserIden,
+				UserName:       v.UserName,
+				UserMobile:     v.UserMobile,
+				Status:         v.Status,
+				RegisterSource: v.RegisterSource,
+				OpenId:         v.OpenId,
+				UnionId:        v.UnionId,
+				Sex:            v.Sex,
+				Avatar:         utils.AddOssDomain(v.Avatar),
+				Title:          v.Title,
+				DepartmentName: v.DepartmentName,
+				HospitalId:     fmt.Sprintf("%d", v.HospitalId),
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetUserDto 详情
+func GetUserDto(m *model.User) *UserDto {
+	return &UserDto{
+		UserId:         fmt.Sprintf("%d", m.UserId),
+		UserIden:       m.UserIden,
+		UserName:       m.UserName,
+		UserMobile:     m.UserMobile,
+		Status:         m.Status,
+		RegisterSource: m.RegisterSource,
+		OpenId:         m.OpenId,
+		UnionId:        m.UnionId,
+		Sex:            m.Sex,
+		Avatar:         utils.AddOssDomain(m.Avatar),
+		Title:          m.Title,
+		DepartmentName: m.DepartmentName,
+		HospitalId:     fmt.Sprintf("%d", m.HospitalId),
+		CreatedAt:      m.CreatedAt,
+		UpdatedAt:      m.UpdatedAt,
+	}
+}