surveyService/service/survey_import/manage.go

package survey_import

import (
	"context"
	"fmt"
	"surveyService/cache"
	"surveyService/model"
	"surveyService/response"
	"surveyService/service/questionnaire_subject"
	"surveyService/service/questionnaire_template"
	"surveyService/util"
	"surveyService/util/rabbitmq"
	"surveyService/validators"

	"github.com/guonaihong/gout"
	jsoniter "github.com/json-iterator/go"
	"gorm.io/gorm"
)

const (
	ListQuestionnaireSubjectCacheKey      = "algor:questionnaireSubject:list"
	HashListQuestionnaireSubjectCacheKey  = "algor:questionnaireSubject:hashList"
	ListQuestionnaireTemplateCacheKey     = "algor:questionnaireTemplate:list"
	HashListQuestionnaireTemplateCacheKey = "algor:questionnaireTemplate:hashList"
)

type SyncData struct {
	Version       string `json:"version" form:"version" binding:"required"`
	VersionNumber int64  `json:"versionNumber" form:"versionNumber" binding:"required"`
	FileUrl       string `json:"fileUrl" form:"fileUrl" binding:"required"`
	ID            int64  `json:"id" form:"id" binding:"required"`
	CallbackUrl   string `json:"callbackUrl" form:"callbackUrl" binding:"required"`
}

type SyncSurveyResult struct {
	Result *SyncSurveyData `json:"result"`
}
type SyncSurveyData struct {
	Subjects  []*model.QuestionnaireSubject  `json:"subjects"`
	Surveys   []*model.QuestionnaireSurvey   `json:"surveys"`
	Templates []*model.QuestionnaireTemplate `json:"templates"`
}

var json = jsoniter.ConfigCompatibleWithStandardLibrary

func StartSync(syncData SyncData) {
	fmt.Println("收到的数据", syncData)
	// 1. 调用同步接口
	err := Sync(syncData)
	if err != nil {
		var webhookMessage rabbitmq.WebhookMessage
		webhookMessage.Body = map[string]any{
			"status": false,
			"id":     syncData.ID,
			"errMsg": err.Msg,
		}
		webhookMessage.Config.Url = syncData.CallbackUrl
		fmt.Println("开始推送数据", util.JsonEncode(webhookMessage))
		pushErr := rabbitmq.Webhook(webhookMessage)
		if pushErr != nil {
			// 更新失败
			fmt.Println("数据推送失败", pushErr)
			// Callback(dataSync.ID, false, "数据推送失败")
			return
		}
		return
	}
	var webhookMessage rabbitmq.WebhookMessage
	webhookMessage.Body = map[string]any{
		"status": true,
		"id":     syncData.ID,
		"errMsg": "",
	}
	webhookMessage.Config.Url = syncData.CallbackUrl
	fmt.Println("开始推送数据", util.JsonEncode(webhookMessage))
	pushErr := rabbitmq.Webhook(webhookMessage)
	if pushErr != nil {
		// 更新失败
		fmt.Println("数据推送失败", pushErr)
		// Callback(dataSync.ID, false, "数据推送失败")
		return
	}
}

func Sync(syncData SyncData) *response.ErrCode {
	// 下载文件
	var body string
	err := gout.GET(syncData.FileUrl).BindBody(&body).Do()
	if err != nil {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "文件下载失败",
		}
	}

	var result *SyncSurveyResult
	json.UnmarshalFromString(body, &result)
	if result == nil {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  "文件解析失败",
		}
	}
	var subjects []*model.QuestionnaireSubject = result.Result.Subjects
	var templates []*model.QuestionnaireTemplate = result.Result.Templates
	var templateSubjects []*model.QuestionnaireTemplateSubject = make([]*model.QuestionnaireTemplateSubject, 0)
	for _, template := range templates {
		for _, templateSubject := range template.SubjectRelations {
			templateSubjects = append(templateSubjects, &model.QuestionnaireTemplateSubject{
				TemplateID: templateSubject.TemplateID,
				SubjectID:  templateSubject.SubjectID,
				Sort:       templateSubject.Sort,
			})
		}
		template.SubjectRelations = make([]*model.QuestionnaireTemplateSubject, 0)
	}
	var surveys []*model.QuestionnaireSurvey = result.Result.Surveys
	var surveySubjects []*model.QuestionnaireSurveyQuestionnaireSubject = make([]*model.QuestionnaireSurveyQuestionnaireSubject, 0)
	for _, survey := range surveys {
		for _, surveySubject := range survey.Subjects {
			surveySubjects = append(surveySubjects, &model.QuestionnaireSurveyQuestionnaireSubject{
				SurveyID:   surveySubject.SurveyID,
				SubjectID:  surveySubject.SubjectID,
				Sort:       surveySubject.Sort,
				IsRequired: surveySubject.IsRequired,
			})
		}
		survey.Subjects = make([]*model.QuestionnaireSurveyQuestionnaireSubject, 0)
	}

	// 开启事务
	updateErr := model.DB.Transaction(func(tx *gorm.DB) error {
		// 删除subjects
		model.DB.Model(&model.QuestionnaireSubject{}).Unscoped().Where("id > 0").Delete(&model.QuestionnaireSubject{})
		// 删除templates
		model.DB.Model(&model.QuestionnaireTemplate{}).Unscoped().Where("id > 0").Delete(&model.QuestionnaireTemplate{})
		// 删除templateSubjects
		model.DB.Model(&model.QuestionnaireTemplateSubject{}).Unscoped().Where("id > 0").Delete(&model.QuestionnaireTemplateSubject{})
		// 删除surveys
		model.DB.Model(&model.QuestionnaireSurvey{}).Unscoped().Where("id > 0").Delete(&model.QuestionnaireSurvey{})
		// 删除surveySubjects
		model.DB.Model(&model.QuestionnaireSurveyQuestionnaireSubject{}).Unscoped().Where("id > 0").Delete(&model.QuestionnaireSurveyQuestionnaireSubject{})
		// 开始创建
		if err := model.DB.Model(&model.QuestionnaireSubject{}).CreateInBatches(subjects, len(subjects)).Error; err != nil {
			return fmt.Errorf("创建subjects失败: %w", err)
		}
		if err := model.DB.Model(&model.QuestionnaireTemplate{}).CreateInBatches(templates, len(templates)).Error; err != nil {
			return fmt.Errorf("创建templates失败: %w", err)
		}
		if err := model.DB.Model(&model.QuestionnaireTemplateSubject{}).CreateInBatches(templateSubjects, len(templateSubjects)).Error; err != nil {
			return fmt.Errorf("创建templateSubjects失败: %w", err)
		}
		if err := model.DB.Model(&model.QuestionnaireSurvey{}).CreateInBatches(surveys, len(surveys)).Error; err != nil {
			return fmt.Errorf("创建surveys失败: %w", err)
		}
		if err := model.DB.Model(&model.QuestionnaireSurveyQuestionnaireSubject{}).CreateInBatches(surveySubjects, len(surveySubjects)).Error; err != nil {
			return fmt.Errorf("创建surveySubjects失败: %w", err)
		}
		return nil
	})
	if updateErr != nil {
		return &response.ErrCode{
			Code: response.ERROR,
			Msg:  updateErr.Error(),
		}
	}

	go CacheList()

	return nil
}

func CacheList() {
	var subjectList = questionnaire_subject.List("")
	var formatedSubjectList []*validators.QuestionnaireSubject
	for _, subject := range subjectList {
		formatedSubjectList = append(formatedSubjectList, questionnaire_subject.Format(subject))
	}
	CacheQuestionnaireSubject(formatedSubjectList)

	var templateList = questionnaire_template.List("")
	var formatedTemplateList []*validators.QuestionnaireTemplate
	for _, template := range templateList {
		formatedTemplateList = append(formatedTemplateList, questionnaire_template.Format(template))
	}
	CacheQuestionnaireTemplate(formatedTemplateList)
}

// 获取问题库列表
func CacheQuestionnaireSubject(list []*validators.QuestionnaireSubject) *response.ErrCode {
	// 删除键
	cache.Instance().Delete(ListQuestionnaireSubjectCacheKey)
	cache.Instance().Delete(HashListQuestionnaireSubjectCacheKey)

	// 存缓存
	listJson, marshalErr := json.Marshal(list)
	if marshalErr != nil {
		return response.Err
	}
	cache.Instance().PutStrForever(ListQuestionnaireSubjectCacheKey, string(listJson))

	// 以ID为键，值为整体来存
	var hashKeys = make([]any, 0)
	for _, item := range list {
		hashKeys = append(hashKeys, item.SN)
		hashKeys = append(hashKeys, util.JsonEncode(item))
	}
	_, rdsErr := cache.GetClient().HMSet(context.Background(), cache.Instance().KeyWithPrefix(HashListQuestionnaireSubjectCacheKey), hashKeys...).Result()
	if rdsErr != nil {
		fmt.Println("同步失败")
	} else {
		fmt.Println("同步成功")
	}
	return nil
}

// 获取问题模板列表
func CacheQuestionnaireTemplate(list []*validators.QuestionnaireTemplate) *response.ErrCode {
	// 删除键
	cache.Instance().Delete(ListQuestionnaireTemplateCacheKey)
	cache.Instance().Delete(HashListQuestionnaireTemplateCacheKey)
	// 存缓存
	listJson, marshalErr := json.Marshal(list)
	if marshalErr != nil {
		return response.Err
	}
	cache.Instance().PutStrForever(ListQuestionnaireTemplateCacheKey, string(listJson))

	// 以ID为键，值为整体来存
	var hashKeys = make([]any, 0)
	for _, item := range list {
		hashKeys = append(hashKeys, item.SN)
		hashKeys = append(hashKeys, util.JsonEncode(item))
	}
	_, rdsErr := cache.GetClient().HMSet(context.Background(), cache.Instance().KeyWithPrefix(HashListQuestionnaireTemplateCacheKey), hashKeys...).Result()
	if rdsErr != nil {
		fmt.Println("同步失败")
	} else {
		fmt.Println("同步成功")
	}
	return nil
}