surveyService/service/survey_result/member.go

package survey_result

import (
	"fmt"
	"surveyService/model"
	"surveyService/response"
	"surveyService/sdk/survey_disease"
	"surveyService/service/survey"
	"surveyService/service/survey_mechanism"
	"surveyService/util"
	"surveyService/validators"

	"github.com/golang-module/carbon"
	jsoniter "github.com/json-iterator/go"
	"gogs.uu.mdfitnesscao.com/hys/sdk"
)

type Member struct {
	MechanismId string // 机构ID
	Member      *sdk.AuthMember
}

func InitMember(member *sdk.AuthMember, mechanismId string) *Member {
	return &Member{
		MechanismId: mechanismId,
		Member:      member,
	}
}

// 获取问卷结果
func (m *Member) Detail(sn string) (*model.SurveyResult, *response.ErrCode) {
	var surveyResult *model.SurveyResult
	tx := model.DB.Where("sn = ?", sn)
	if m.Member != nil {
		tx = tx.Where("archives_id = ?", m.Member.ID)
	}

	err := tx.Preload("SurveyMechanism").First(&surveyResult).Error
	if err != nil {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "获取问卷结果失败",
		}
	}

	if m.MechanismId != surveyResult.SurveyMechanism.MechanismId {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "没有找到有效的问卷结果数据",
		}
	}

	return surveyResult, nil
}

// 获取最后一份问卷结果
func (m *Member) DetailLastSurvey(surveyMechanismId int64, isPhysicalSurvey bool) (*model.SurveyResult, *response.ErrCode) {
	var surveyResult *model.SurveyResult

	// 如果是定制体检
	if isPhysicalSurvey {
		var physicalSurver *model.Survey
		// 查出哪份问卷是定制体检
		err := model.DB.Model(&model.Survey{}).Where(&model.Survey{
			Type: model.SURVEY_TYPE_PHYSICAL,
		}).First(&physicalSurver).Error
		if err != nil {
			return nil, &response.ErrCode{
				Code: response.ERROR,
				Msg:  "定制体检问卷未设置",
			}
		}
		var surveyMechanism *model.SurveyMechanism
		// 开始查找机构授权的问卷
		err = model.DB.Model(&model.SurveyMechanism{}).Where(&model.SurveyMechanism{
			SurveyId:    physicalSurver.ID,
			MechanismId: m.MechanismId,
		}).First(&surveyMechanism).Error
		if err != nil {
			return nil, &response.ErrCode{
				Code: response.ERROR,
				Msg:  "机构未授权定制体检问卷",
			}
		}
		surveyMechanismId = surveyMechanism.ID
	}

	tx := model.DB.Where(&model.SurveyResult{
		SurveyMechanismId: surveyMechanismId,
	})
	if m.Member != nil {
		tx = tx.Where("archives_id = ?", m.Member.ID)
	}

	err := tx.Preload("SurveyMechanism").First(&surveyResult).Error
	if err != nil {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "获取问卷结果失败",
		}
	}

	if m.MechanismId != surveyResult.SurveyMechanism.MechanismId {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "没有找到有效的问卷结果数据",
		}
	}

	return surveyResult, nil
}

// 获取问卷结果
func (m *Member) Paginate(page, pageSize int) ([]*model.SurveyResult, int64) {
	var surveyResults []*model.SurveyResult
	var total int64
	tx := model.DB.Model(&model.SurveyResult{})
	if m.Member != nil {
		tx = tx.Where("archives_id = ?", m.Member.ID)
	}
	var surveyMechanismTableName = (&model.SurveyMechanism{}).TableName()
	var surveyResultTableName = (&model.SurveyResult{}).TableName()
	tx = tx.Joins(fmt.Sprintf("left join %s on %s.id = %s.survey_mechanism_id", surveyMechanismTableName, surveyMechanismTableName, surveyResultTableName)).Where(fmt.Sprintf("%s.mechanism_id = ?", surveyMechanismTableName), m.MechanismId)
	tx.Count(&total)
	tx.Select(fmt.Sprintf("%s.*", surveyResultTableName)).Scopes(model.Paginate(page, pageSize)).Order(fmt.Sprintf("%s.id desc", surveyResultTableName)).Preload("SurveyMechanism").Find(&surveyResults)

	return surveyResults, total
}

// 创建问卷结果
// surveyMechanismId 机构问卷编号
func (m *Member) Create(surveyMechanismId string, extra string) (*model.SurveyResult, *response.ErrCode) {
	// 检查问卷是否在
	surveyMechanism, findErr := survey_mechanism.InitMember(m.Member, m.MechanismId).Detail(surveyMechanismId)
	if findErr != nil {
		return nil, findErr
	}

	// 检查是否有未完成的问卷
	if extra != "" {
		var existsSurveyResult *model.SurveyResult
		model.DB.Where("extra = ?", extra).First(&existsSurveyResult)
		if existsSurveyResult != nil {
			// 检查是否可以继续作答
			if existsSurveyResult.Status == model.SurveyResultStatusWait {
				return existsSurveyResult, nil
			}
		}
	}

	archivesId := ""
	if m.Member != nil {
		archivesId = m.Member.ID
	}

	surveyResultModel := model.SurveyResult{
		StartTime:         carbon.Now().Carbon2Time(),
		SurveyMechanismId: surveyMechanism.ID,
		Status:            model.SurveyResultStatusWait,
		Method:            model.SurveyResultMethodArchives,
		MechanismId:       m.MechanismId,
		ArchivesId:        archivesId,
		Extra:             extra,
	}

	err := model.DB.Create(&surveyResultModel).Error
	if err != nil {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "创建问卷结果失败",
		}
	}

	return &surveyResultModel, nil
}

// 提交答题结果
func (m *Member) Submit(sn string, answers map[string]any) *response.ErrCode {
	// 获取问卷结果
	surveyResult, findErr := m.Detail(sn)
	if findErr != nil {
		return findErr
	}

	// 只有在填写中的问卷才能保存
	if surveyResult.Status != model.SurveyResultStatusWait {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "问卷结果已经提交，不能再保存",
		}
	}

	if m.Member != nil {
		if surveyResult.ArchivesId != m.Member.ID {
			return &response.ErrCode{
				Code: response.ERROR,
				Msg:  "答题问卷不存在",
			}
		}
	}

	// 只有后台新增的才可以修改
	// if surveyResult.Method == model.SurveyResultMethodArchives {
	// 	return &response.ErrCode{
	// 		Code: response.ERROR,
	// 		Msg:  "当前问卷不支持修改答题结果",
	// 	}
	// }

	// 保存问卷结果
	updateErr := model.DB.Model(model.SurveyResult{}).Where("id = ?", surveyResult.ID).Select([]string{"AnswerRaw", "Status"}).Updates(&model.SurveyResult{
		AnswerRaw: util.JsonEncode(answers),
		Status:    model.SurveyResultStatusFulled,
		EndTime:   carbon.Now().Carbon2Time(),
	}).Error
	if updateErr != nil {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "提交问卷失败",
		}
	}

	_, findErr = survey.Find(surveyResult.SurveyMechanism.SurveyId)
	if findErr != nil {
		return findErr
	}

	// 提交问卷结果数据
	go func() {

		// 将answer转成指定格式
		var formatedAnswers map[string]*sdk.SurveyAnswer
		jsoniter.UnmarshalFromString(util.JsonEncode(answers), &formatedAnswers)
		surveyDiseaseCalcResult := survey_disease.DiseaseScreeningCal(
			formatedAnswers,
		)
		ProcessResult(sn, surveyDiseaseCalcResult)
	}()

	return nil
}

// 创建并提交问卷结果
func (m *Member) CreateAndSubmit(surveyMechanismId string, answers map[string]any, startTime string, extra string) (*model.SurveyResult, *response.ErrCode) {
	// 检查问卷是否在
	surveyMechanism, findErr := survey_mechanism.InitMember(m.Member, m.MechanismId).Detail(surveyMechanismId)
	if findErr != nil {
		return nil, findErr
	}

	archivesId := ""
	if m.Member != nil {
		archivesId = m.Member.ID
	}

	// 如果开始时间大于当前时间，报错
	startTimeCarbon := carbon.Parse(startTime)
	if startTimeCarbon.Gte(carbon.Now()) {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "开始时间不能大于当前时间",
		}
	}

	surveyResultModel := &model.SurveyResult{
		StartTime:         startTimeCarbon.Carbon2Time(),
		SurveyMechanismId: surveyMechanism.ID,
		Method:            model.SurveyResultMethodArchives,
		MechanismId:       m.MechanismId,
		ArchivesId:        archivesId,
		Extra:             extra,
		AnswerRaw:         util.JsonEncode(answers),
		Status:            model.SurveyResultStatusFulled,
		EndTime:           carbon.Now().Carbon2Time(),
	}

	err := model.DB.Save(&surveyResultModel).Error
	if err != nil {
		return nil, &response.ErrCode{
			Code: response.ERROR,
			Msg:  "问卷提交失败",
		}
	}

	_, findErr = survey.Find(surveyMechanism.SurveyId)
	if findErr != nil {
		return nil, findErr
	}

	go func() {
		var formatedAnswers map[string]*sdk.SurveyAnswer
		jsoniter.UnmarshalFromString(util.JsonEncode(answers), &formatedAnswers)
		surveyDiseaseCalcResult := survey_disease.DiseaseScreeningCal(
			formatedAnswers,
		)
		ProcessResult(surveyResultModel.SN, surveyDiseaseCalcResult)
	}()
	return surveyResultModel, nil
}

// 格式化答题结果
func (m *Member) Format(rawSurveyResult *model.SurveyResult, needResult bool) *validators.SurveyResult {
	var answerResult map[string]any
	var resultRaw string
	if needResult {
		if rawSurveyResult.AnswerRaw != "" {
			json.UnmarshalFromString(rawSurveyResult.AnswerRaw, &answerResult)
		}
		resultRaw = rawSurveyResult.ResultRaw
	}
	return &validators.SurveyResult{
		ID:                rawSurveyResult.SN,
		Method:            rawSurveyResult.Method,
		StartTime:         carbon.Time2Carbon(rawSurveyResult.StartTime).Format("Y/m/d H:i:s"),
		EndTime:           carbon.Time2Carbon(rawSurveyResult.EndTime).Format("Y/m/d H:i:s"),
		Status:            rawSurveyResult.Status,
		ArchivesId:        rawSurveyResult.ArchivesId,
		AnswerResult:      answerResult,
		ResultRaw:         resultRaw,
		SurveyMechanismId: (&model.SurveyMechanism{}).GetHashId(rawSurveyResult.SurveyMechanismId),
		SurveyMechanism:   survey_mechanism.ListFormat([]*model.SurveyMechanism{rawSurveyResult.SurveyMechanism})[0],
		CreatedAt:         carbon.Time2Carbon(rawSurveyResult.CreatedAt).Format("Y/m/d H:i:s"),
		UpdatedAt:         carbon.Time2Carbon(rawSurveyResult.UpdatedAt).Format("Y/m/d H:i:s"),
	}
}