worker/answerwc/respondent.go
2024-02-19 21:20:09 +03:00

171 lines
4.2 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package answerwc
import (
"context"
"encoding/json"
"fmt"
"github.com/go-redis/redis/v8"
"github.com/themakers/hlog"
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
"penahub.gitlab.yandexcloud.net/backend/quiz/worker.git/clients/mailclient"
"penahub.gitlab.yandexcloud.net/backend/quiz/worker.git/wctools"
"time"
)
type DepsRespWorker struct {
Redis *redis.Client
Dal *dal.DAL
MailClient *mailclient.Client
}
type RespWorker struct {
deps DepsRespWorker
logger hlog.Logger
errChan chan<- error
}
func NewRespWorker(deps DepsRespWorker, logger hlog.Logger, errChan chan<- error) *RespWorker {
return &RespWorker{
deps: deps,
logger: logger,
errChan: errChan,
}
}
func (w *RespWorker) Start(ctx context.Context) {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
w.processPendingAnswer(ctx)
case <-ctx.Done():
w.logger.Module("To respondent worker terminated")
return
}
}
}
func (w *RespWorker) processPendingAnswer(ctx context.Context) {
keys, err := w.deps.Redis.Keys(ctx, "toRespondent:*").Result()
if err != nil {
w.reportError(err, "Error retrieving keys from Redis")
return
}
for _, key := range keys {
func() {
answerJSON, err := w.deps.Redis.GetDel(ctx, key).Result()
if err == redis.Nil {
return
} else if err != nil {
w.reportError(err, "Error getting and deleting data from Redis")
return
}
defer func() {
if r := recover(); r != nil {
w.reportError(nil, fmt.Sprintf("recovering from panic or error setting redis value %v", r))
_ = w.deps.Redis.Set(ctx, key, answerJSON, 0).Err()
}
}()
var answer model.Answer
err = json.Unmarshal([]byte(answerJSON), &answer)
if err != nil {
w.reportError(err, "Error unmarshalling answer")
return
}
answerContent, err := wctools.ProcessAnswer(answer.Content)
if err != nil {
w.reportError(err, "Error processing answer content")
return
}
quizConfig, accountId, err := w.deps.Dal.QuizRepo.GetQuizConfig(ctx, answer.QuizId)
if err != nil {
w.reportError(err, "Error getting quiz config")
return
}
quiz, err := w.deps.Dal.QuizRepo.GetQuizById(ctx, accountId, answer.QuizId)
if err != nil {
w.reportError(err, "Error getting quiz")
return
}
quizConfig.Mailing.Reply = quiz.Name
if quizConfig.Mailing.Theme == "" {
quizConfig.Mailing.Theme = quiz.Name
}
allAnswers, err := w.deps.Dal.AnswerRepo.GetAllAnswersByQuizID(ctx, answer.Session)
if err != nil {
w.reportError(err, "Error getting all answers by quizID")
return
}
questionsMap, err := w.deps.Dal.QuestionRepo.GetMapQuestions(ctx, allAnswers)
if err != nil {
w.reportError(err, "Error getting questionsMap")
return
}
fmt.Println("ATATATA", questionsMap, allAnswers)
err = w.processMessageToSMTP(quizConfig, questionsMap, allAnswers, answerContent, answer.CreatedAt)
if err != nil {
w.reportError(err, "Error sending message to SMTP")
}
}()
}
}
func (w *RespWorker) processMessageToSMTP(quizConfig model.QuizConfig, questionsMap map[uint64]string,
allAnswers []model.ResultAnswer, answerContent model.ResultContent, answerTime time.Time) error {
theme := quizConfig.Mailing.Theme
quizConfig.Mailing.Theme = quizConfig.Mailing.Reply
data := mailclient.EmailTemplateData{
QuizConfig: quizConfig.Mailing,
AnswerContent: answerContent,
AllAnswers: allAnswers,
QuestionsMap: questionsMap,
}
dayOfWeek := wctools.DaysOfWeek[answerTime.Format("Monday")]
monthOfYear := wctools.MonthsOfYear[answerTime.Format("January")]
formattedTime := fmt.Sprintf("%s, %d %s %d г., %02d:%02d (UTC%s)",
dayOfWeek,
answerTime.Day(),
monthOfYear,
answerTime.Year(),
answerTime.Hour(),
answerTime.Minute(),
answerTime.Format("-07:00"),
)
data.AnswerTime = formattedTime
err := w.deps.MailClient.SendMailWithAttachment(answerContent.Email, theme, toClientTemplate, data, nil)
if err != nil {
return err
}
return nil
}
func (w *RespWorker) reportError(err error, message string) {
if err != nil {
fmt.Println(message + ": " + err.Error())
w.errChan <- err
}
}