first

api/dto/AdminUser.go

@@ -0,0 +1,75 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"case-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,48 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+)
+
+// BasicHospitalDto 基础数据-医院
+type BasicHospitalDto struct {
+	HospitalId    string          `json:"hospital_id"`    // 主键id
+	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),
+				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
+}

api/dto/Case.go

@@ -0,0 +1,101 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+	"time"
+)
+
+// 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"`    // 病例作者
+	IssuedScore  int             `json:"issued_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"`     // 修改时间
+	CaseItem     []*CaseItemDto  `json:"case_item"`      // 病例明细
+	IsNew        int             `json:"is_new"`         // 是否为新病例(最近7天)
+	IsJoin       int             `json:"is_join"`        // 是否参与过（区分平台）
+	IsWelfare    int             `json:"is_welfare"`     // 是否存在福利（区分平台）
+}
+
+// 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
+}
+
+// LoadIsNew 加载是否为新病例(最近7天)
+func (r *CaseDto) LoadIsNew(t model.LocalTime) *CaseDto {
+	now := time.Now()
+	createdAt := time.Time(t)
+	diffTime := createdAt.Sub(now)
+	if diffTime <= 7*24*time.Hour {
+		r.IsNew = 1
+	}
+
+	return r
+}
+
+// LoadIsJoin 加载是否已参与
+func (r *CaseDto) LoadIsJoin(m bool) *CaseDto {
+	if m {
+		r.IsJoin = 1
+	}
+	return r
+}

api/dto/CaseComment.go

@@ -0,0 +1,129 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"case-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:正常）
+	UserName           string            `json:"user_name"`             // 用户名称
+	AreaName           string            `json:"area_name"`             // 地址名称
+	HospitalName       string            `json:"hospital_name"`         // 医院名称
+	DepartmentName     string            `json:"department_name"`       // 科室名称
+	Title              string            `json:"title"`                 // 职称
+	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"`            // 修改时间
+	CaseComment        []*CaseCommentDto `json:"case_comment"`          // 次级评论
+	IsLike             bool              `json:"is_like"`               // 点赞状态（0:否 1:是）
+	TotalAmount        int64             `json:"total_amount"`          // 剩余评论数量
+}
+
+// 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,
+				IsHighQuality: v.IsHighQuality,
+				LikeNum:       v.LikeNum,
+				Content:       v.Content,
+				ContentWord:   v.ContentWord,
+				CreatedAt:     v.CreatedAt,
+				UpdatedAt:     v.UpdatedAt,
+			}
+
+			// 加载数据-用户字段
+			if v.User != nil {
+				response = response.LoadUser(v.User)
+
+				// 加载数据-医院字段
+				if v.User.Hospital != nil {
+					response = response.LoadHospital(v.User.Hospital)
+				}
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadCaseComment 加载数据-次级评论
+func (r *CaseCommentDto) LoadCaseComment(m []*model.CaseComment) *CaseCommentDto {
+	if len(m) > 0 {
+		r.CaseComment = GetCaseCommentListDto(m)
+	}
+
+	return r
+}
+
+// LoadIsLike 加载数据-点赞
+func (r *CaseCommentDto) LoadIsLike(m int64) *CaseCommentDto {
+	if m > 0 {
+		r.IsLike = true
+	}
+
+	return r
+}
+
+// LoadTotalAmount 加载数据-剩余数量
+func (r *CaseCommentDto) LoadTotalAmount(m int64) *CaseCommentDto {
+	if m > 0 {
+		r.TotalAmount = m
+	}
+
+	return r
+}
+
+// LoadUser 加载数据-用户字段
+func (r *CaseCommentDto) LoadUser(m *model.User) *CaseCommentDto {
+	if m != nil {
+		r.UserName = m.UserName
+		r.DepartmentName = m.DepartmentName
+		r.Title = utils.DoctorTitleToString(m.Title)
+
+		if m.Address != "" {
+			r.AreaName = m.Address
+		}
+	}
+
+	return r
+}
+
+// LoadHospital 加载数据-医院字段
+func (r *CaseCommentDto) LoadHospital(m *model.BasicHospital) *CaseCommentDto {
+	if m != nil {
+		r.HospitalName = m.HospitalName
+
+		if m.Address == "" {
+			r.AreaName = m.Province
+		}
+	}
+
+	return r
+}

api/dto/CaseItem.go

@@ -0,0 +1,59 @@
+package dto
+
+import (
+	"case-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
+}
+
+// LoadCaseItemQuestionList 加载数据-病例明细-题目
+func (r *CaseItemDto) LoadCaseItemQuestionList(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-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,76 @@
+package dto
+
+import (
+	"case-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 len(v.CaseItemQuestionOption) > 0 {
+				response = response.LoadCaseItemQuestionOption(v.CaseItemQuestionOption)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetCaseItemQuestionDto 详情
+func GetCaseItemQuestionDto(m *model.CaseItemQuestion) *CaseItemQuestionDto {
+	return &CaseItemQuestionDto{
+		QuestionId:     fmt.Sprintf("%d", m.QuestionId),
+		CaseItemId:     fmt.Sprintf("%d", m.CaseItemId),
+		QuestionName:   m.QuestionName,
+		QuestionType:   m.QuestionType,
+		QuestionAnswer: m.QuestionAnswer,
+		IsRightNext:    m.IsRightNext,
+		ErrorTips:      m.ErrorTips,
+		CreatedAt:      m.CreatedAt,
+		UpdatedAt:      m.UpdatedAt,
+	}
+}
+
+// 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,54 @@
+package dto
+
+import (
+	"case-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"`   // 修改时间
+	Proportion  float64         `json:"proportion"`   // 被选择占比
+	SelectNum   int             `json:"select_num"`   // 被选择数量
+}
+
+// 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
+}
+
+// LoadProportion 加载数据-占比
+func (r *CaseItemQuestionOptionDto) LoadProportion(m float64) *CaseItemQuestionOptionDto {
+	r.Proportion = m
+
+	return r
+}
+
+// LoadSelectNum 加载数据-被选择数量
+func (r *CaseItemQuestionOptionDto) LoadSelectNum(m int) *CaseItemQuestionOptionDto {
+	r.SelectNum = m
+
+	return r
+}

api/dto/CaseUser.go

@@ -0,0 +1,37 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+	"strings"
+)
+
+// CaseUserDto 统计数据-病例-用户
+type CaseUserDto struct {
+	CaseUserId string `json:"case_user_id"` // 主键id
+	TotalScore int    `json:"total_score"`  // 单个病例领取总积分
+	Describe   string `json:"describe"`     // 描述
+}
+
+// GetCaseUserDto 详情
+func GetCaseUserDto(m *model.CaseUser) *CaseUserDto {
+	return &CaseUserDto{
+		CaseUserId: fmt.Sprintf("%d", m.CaseUserId),
+		TotalScore: m.TotalScore,
+	}
+}
+
+// LoadDescribe 加载数据-描述
+func (r *CaseUserDto) LoadDescribe(m []*model.RecordScore) *CaseUserDto {
+	if len(m) > 0 {
+		var describe []string
+		for _, score := range m {
+			d := score.NodeName + ":" + fmt.Sprintf("%d", score.Score)
+			describe = append(describe, d)
+		}
+
+		r.Describe = strings.Join(describe, ", ")
+	}
+
+	return r
+}

api/dto/Platform.go

@@ -0,0 +1,55 @@
+package dto
+
+import (
+	"case-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,74 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"case-api/utils"
+	"fmt"
+)
+
+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"`         // 关联病例数量
+	IsRecentlyUpdate int             `json:"is_recently_update"` // 是否最近有更新(最近7天)
+	IsWelfare        int             `json:"is_welfare"`         // 是否存在福利（区分平台）
+}
+
+// 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)
+
+			// 将转换后的结构体添加到新切片中
+			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
+}
+
+// LoadIsRecentlyUpdate 加载最近更新情况
+func (r *ProjectDto) LoadIsRecentlyUpdate(m *model.Case) *ProjectDto {
+	if m != nil {
+		r.IsRecentlyUpdate = 1
+	}
+	return r
+}

api/dto/ProjectPlatform.go

@@ -0,0 +1,101 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDto 项目表-关联平台
+type ProjectPlatformDto struct {
+	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"`          // 平台名称
+	IsWhiteUser         int             `json:"is_white_user"`          // 登录用户是否白名单用户（0:否 1:是）
+}
+
+// GetProjectPlatformListDto 列表
+func GetProjectPlatformListDto(m []*model.ProjectPlatform) []*ProjectPlatformDto {
+	// 处理返回值
+	responses := make([]*ProjectPlatformDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &ProjectPlatformDto{
+				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{
+		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
+}
+
+// LoadIsWhiteUser 加载数据-用户白名单
+func (r *ProjectPlatformDto) LoadIsWhiteUser(isWhite bool) *ProjectPlatformDto {
+	if isWhite == true {
+		r.IsWhiteUser = 1
+	}
+
+	return r
+}

api/dto/ProjectPlatformDoctor.go

@@ -0,0 +1,53 @@
+package dto
+
+import (
+	"case-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 len(m) > 0 {
+		r.User = GetUserListDto(m)
+	}
+
+	return r
+}

api/dto/ProjectPlatformDynamic.go

@@ -0,0 +1,50 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+)
+
+// ProjectPlatformDynamicDto 关联平台-白名单-动态
+type ProjectPlatformDynamicDto struct {
+	WhiteDynamicId                string                           `json:"white_dynamic_id"`    // 主键id"
+	ProjectPlatformId             string                           `json:"project_platform_id"` // 关联id
+	DynamicType                   string                           `json:"dynamic_type"`        // 动态类型（area:省份 level:医院等级 title:职称 department:科室 url:地址栏 类型间以-链接）
+	Status                        int                              `json:"status"`              // 状态（1:正常 2:禁用）
+	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-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-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 len(m) > 0 {
+		r.BasicHospital = GetBasicHospitalListDto(m)
+	}
+
+	return r
+}

api/dto/Public.go

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

api/dto/StatCaseQuestion.go

@@ -0,0 +1,55 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"fmt"
+)
+
+type StatCaseQuestionDto struct {
+	StatId      string          `json:"stat_id"`      // 主键id
+	CaseId      string          `json:"case_id"`      // 病例id
+	QuestionId  string          `json:"question_id"`  // 题目id
+	OptionId    string          `json:"option_id"`    // 选项id
+	OptionValue string          `json:"option_value"` // 选项内容
+	SelectNum   int             `json:"select_num"`   // 被选择数量
+	CreatedAt   model.LocalTime `json:"created_at"`   // 创建时间
+	UpdatedAt   model.LocalTime `json:"updated_at"`   // 修改时间
+	Proportion  float64         `json:"proportion"`   // 占比
+}
+
+// GetStatCaseQuestionListDto 列表
+func GetStatCaseQuestionListDto(m []*model.StatCaseQuestion) []*StatCaseQuestionDto {
+	// 处理返回值
+	responses := make([]*StatCaseQuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &StatCaseQuestionDto{
+				StatId:     fmt.Sprintf("%d", v.StatId),
+				CaseId:     fmt.Sprintf("%d", v.CaseId),
+				QuestionId: fmt.Sprintf("%d", v.QuestionId),
+				OptionId:   fmt.Sprintf("%d", v.QuestionId),
+				SelectNum:  v.SelectNum,
+			}
+
+			// 加载数据-选项内容
+			if v.CaseItemQuestionOption != nil {
+				response.LoadOptionValue(v.CaseItemQuestionOption)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadOptionValue 加载数据-选项内容
+func (r *StatCaseQuestionDto) LoadOptionValue(m *model.CaseItemQuestionOption) *StatCaseQuestionDto {
+	if m != nil {
+		r.OptionValue = m.OptionValue
+	}
+
+	return r
+}

api/dto/User.go

@@ -0,0 +1,59 @@
+package dto
+
+import (
+	"case-api/api/model"
+	"case-api/utils"
+	"fmt"
+)
+
+// UserDto 用户表
+type UserDto struct {
+	UserId         string          `json:"user_id"`         // 主键id
+	UserIden       string          `json:"user_iden"`       // 第三方平台唯一标识
+	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
+}