748 lines
21 KiB
Go
748 lines
21 KiB
Go
package service
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"gitea.pena/PenaSide/common/log_mw"
|
||
"gitea.pena/SQuiz/answerer/clients"
|
||
"gitea.pena/SQuiz/answerer/dal"
|
||
"gitea.pena/SQuiz/answerer/models"
|
||
quizdal "gitea.pena/SQuiz/common/dal"
|
||
"gitea.pena/SQuiz/common/middleware"
|
||
"gitea.pena/SQuiz/common/model"
|
||
"gitea.pena/SQuiz/common/utils"
|
||
"github.com/gofiber/fiber/v2"
|
||
"io"
|
||
"net/url"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/rs/xid"
|
||
)
|
||
|
||
const (
|
||
quizIdCookie = "qud"
|
||
fingerprintCookie = "fp"
|
||
)
|
||
|
||
type Service struct {
|
||
store *dal.Storer
|
||
dal *quizdal.DAL
|
||
batch []model.Answer
|
||
m sync.Mutex
|
||
workerRespondentCh chan<- []model.Answer
|
||
workerSendClientCh chan<- model.Answer
|
||
encrypt *utils.Encrypt
|
||
redirectURl string
|
||
aiClient *clients.AIClient
|
||
|
||
script scriptTemplate
|
||
}
|
||
|
||
type ServiceDeps struct {
|
||
Store *dal.Storer
|
||
Dal *quizdal.DAL
|
||
WorkerRespondentCh chan<- []model.Answer
|
||
WorkerSendClientCh chan<- model.Answer
|
||
Encrypt *utils.Encrypt
|
||
RedirectURl string
|
||
AiClient *clients.AIClient
|
||
}
|
||
|
||
type scriptTemplate struct {
|
||
full []byte
|
||
mu sync.RWMutex
|
||
}
|
||
|
||
func New(deps ServiceDeps) *Service {
|
||
return &Service{
|
||
store: deps.Store,
|
||
dal: deps.Dal,
|
||
m: sync.Mutex{},
|
||
batch: []model.Answer{},
|
||
workerRespondentCh: deps.WorkerRespondentCh,
|
||
workerSendClientCh: deps.WorkerSendClientCh,
|
||
encrypt: deps.Encrypt,
|
||
redirectURl: deps.RedirectURl,
|
||
aiClient: deps.AiClient,
|
||
}
|
||
}
|
||
|
||
func (s *Service) Register(app *fiber.App) *fiber.App {
|
||
app.Post("/answer", s.PutAnswersOnePiece)
|
||
app.Post("/settings", s.GetQuizData)
|
||
app.Get("/logo", s.MiniPart)
|
||
|
||
app.Put("/pub.js", s.UploadScriptTemplate)
|
||
app.Get("/pub/:qID.js", s.GetScriptTemplate)
|
||
return app
|
||
}
|
||
|
||
// GetQuizDataReq request data for get data for user
|
||
type GetQuizDataReq struct {
|
||
QuizId string `json:"quiz_id"` // relation to quiz
|
||
Limit uint64 `json:"limit"`
|
||
Page uint64 `json:"page"`
|
||
NeedConfig bool `json:"need_config"` // true if you need not only question page
|
||
Auditory int64 `json:"auditory"`
|
||
}
|
||
|
||
// GetQuizDataResp response with prepared data for user
|
||
type GetQuizDataResp struct {
|
||
Settings *ShavedQuiz `json:"settings,omitempty"`
|
||
Items []ShavedQuestion `json:"items"`
|
||
Count uint64 `json:"cnt"`
|
||
ShowBadge bool `json:"show_badge"`
|
||
}
|
||
|
||
// ShavedQuiz shortened struct for delivery data to customer
|
||
type ShavedQuiz struct {
|
||
Fingerprinting bool `json:"fp"`
|
||
Repeatable bool `json:"rep"`
|
||
Name string `json:"name"`
|
||
Config string `json:"cfg"`
|
||
Limit uint64 `json:"lim"`
|
||
DueTo uint64 `json:"due"`
|
||
TimeOfPassing uint64 `json:"delay"`
|
||
Pausable bool `json:"pausable"`
|
||
Status string `json:"status"`
|
||
}
|
||
|
||
// ShavedQuestion shortened struct for delivery data to customer
|
||
type ShavedQuestion struct {
|
||
Id uint64 `json:"id"`
|
||
Title string `json:"title"`
|
||
Description string `json:"desc"`
|
||
Type string `json:"typ"`
|
||
Required bool `json:"req"`
|
||
Page int `json:"p"`
|
||
Content string `json:"c"`
|
||
}
|
||
|
||
// GetQuizData handler for obtaining data for quiz front rendering
|
||
func (s *Service) GetQuizData(c *fiber.Ctx) error {
|
||
cs, ok := c.Context().Value(middleware.ContextKey(middleware.SessionKey)).(string)
|
||
if !ok {
|
||
return c.Status(fiber.StatusUnauthorized).SendString("no session in cookie")
|
||
}
|
||
|
||
hlogger := log_mw.ExtractLogger(c)
|
||
var req GetQuizDataReq
|
||
if err := c.BodyParser(&req); err != nil {
|
||
return c.Status(fiber.StatusBadRequest).SendString("Invalid request data")
|
||
}
|
||
|
||
if req.QuizId == "" {
|
||
return c.Status(fiber.StatusBadRequest).SendString("Invalid request data")
|
||
}
|
||
|
||
if req.Limit == 0 && !req.NeedConfig {
|
||
return c.Status(fiber.StatusLengthRequired).SendString("no data requested")
|
||
}
|
||
|
||
quiz, err := s.dal.QuizRepo.GetQuizByQid(c.Context(), req.QuizId)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
|
||
if req.Limit == 0 && req.NeedConfig {
|
||
quizDto := dao2dtoQuiz(quiz)
|
||
return c.Status(fiber.StatusOK).JSON(GetQuizDataResp{
|
||
Settings: &quizDto,
|
||
})
|
||
}
|
||
|
||
if quiz.UniqueAnswers {
|
||
//todo implement after creating store answers
|
||
}
|
||
if quiz.Status != model.StatusStart && quiz.Status != model.StatusAI {
|
||
return c.Status(fiber.StatusLocked).SendString("quiz is inactive")
|
||
}
|
||
|
||
if quiz.Limit > 0 {
|
||
// todo implement after creating store answer
|
||
}
|
||
|
||
if quiz.DueTo < uint64(time.Now().Unix()) && quiz.DueTo > 0 {
|
||
return c.Status(fiber.StatusGone).SendString("quiz timeouted")
|
||
}
|
||
|
||
account, err := s.dal.AccountRepo.GetAccountByID(c.Context(), quiz.AccountId)
|
||
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("can`t get account by quiz.AccountId")
|
||
}
|
||
|
||
showBadge := true
|
||
|
||
if priv, ok := account.Privileges["squizHideBadge"]; ok {
|
||
expiration := priv.CreatedAt.Add(time.Duration(priv.Amount) * 24 * time.Hour)
|
||
|
||
if time.Now().Before(expiration) {
|
||
showBadge = false
|
||
}
|
||
}
|
||
|
||
var questions []model.Question
|
||
var cnt uint64
|
||
|
||
if quiz.Status == model.StatusAI {
|
||
questions, cnt, err = s.dal.QuestionRepo.GetQuestionsAI(c.Context(), int64(quiz.Id), cs, int32(req.Limit), int32(req.Page*req.Limit), req.Auditory)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
} else {
|
||
questions, cnt, err = s.dal.QuestionRepo.GetQuestionList(
|
||
c.Context(),
|
||
req.Limit,
|
||
req.Page*req.Limit,
|
||
0, 0, quiz.Id, false, false, "", "", req.Auditory,
|
||
)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
}
|
||
|
||
result := GetQuizDataResp{
|
||
Count: cnt,
|
||
Items: []ShavedQuestion{},
|
||
ShowBadge: showBadge,
|
||
}
|
||
|
||
if req.NeedConfig {
|
||
quizDto := dao2dtoQuiz(quiz)
|
||
result.Settings = &quizDto
|
||
}
|
||
|
||
for _, q := range questions {
|
||
result.Items = append(result.Items, dao2dtoQuestion(q))
|
||
}
|
||
|
||
utmData := model.UTMSavingMap{
|
||
"utm_content": c.Query("utm_content"),
|
||
"utm_medium": c.Query("utm_medium"),
|
||
"utm_campaign": c.Query("utm_campaign"),
|
||
"utm_source": c.Query("utm_source"),
|
||
"utm_term": c.Query("utm_term"),
|
||
"utm_referrer": c.Query("utm_referrer"),
|
||
"roistat": c.Query("roistat"),
|
||
"referrer": c.Query("referrer"),
|
||
"openstat_service": c.Query("openstat_service"),
|
||
"openstat_campaign": c.Query("openstat_campaign"),
|
||
"openstat_ad": c.Query("openstat_ad"),
|
||
"openstat_source": c.Query("openstat_source"),
|
||
"from": c.Query("from"),
|
||
"gclientid": c.Query("gclientid"),
|
||
"_ym_uid": c.Query("_ym_uid"),
|
||
"_ym_counter": c.Query("_ym_counter"),
|
||
"gclid": c.Query("gclid"),
|
||
"yclid": c.Query("yclid"),
|
||
"fbclid": c.Query("fbclid"),
|
||
}
|
||
|
||
deviceType := c.Get("DeviceType")
|
||
os := c.Get("OS")
|
||
browser := c.Get("Browser")
|
||
ip := c.IP()
|
||
device := c.Get("Device")
|
||
referrer := c.Get("Referer")
|
||
fp := ""
|
||
if cfp := c.Cookies(fingerprintCookie); cfp != "" {
|
||
fp = cfp
|
||
}
|
||
|
||
if req.NeedConfig {
|
||
if len(questions) == 0 {
|
||
return c.Status(fiber.StatusNotFound).SendString("question not found")
|
||
}
|
||
|
||
answers, errs := s.dal.AnswerRepo.CreateAnswers(c.Context(), []model.Answer{{
|
||
Content: "start",
|
||
QuestionId: questions[0].Id,
|
||
QuizId: quiz.Id,
|
||
Start: true,
|
||
DeviceType: deviceType,
|
||
Device: device,
|
||
Browser: browser,
|
||
IP: ip,
|
||
OS: os,
|
||
Utm: utmData,
|
||
}}, cs, fp, quiz.Id)
|
||
if len(errs) != 0 {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(errs[0].Error())
|
||
}
|
||
|
||
hlogger.Emit(models.InfoQuizOpen{
|
||
KeyOS: os,
|
||
KeyDevice: device,
|
||
KeyDeviceType: deviceType,
|
||
KeyBrowser: browser,
|
||
CtxQuiz: req.QuizId,
|
||
CtxQuizID: int64(quiz.Id),
|
||
CtxReferrer: referrer,
|
||
CtxIDInt: int64(answers[0].Id),
|
||
CtxSession: cs,
|
||
})
|
||
}
|
||
|
||
fmt.Println("SETTIIIIII", cnt <= req.Limit, result)
|
||
|
||
if cnt <= req.Limit {
|
||
return c.Status(fiber.StatusOK).JSON(result)
|
||
} else {
|
||
return c.Status(fiber.StatusPartialContent).JSON(result)
|
||
}
|
||
}
|
||
|
||
func dao2dtoQuestion(question model.Question) ShavedQuestion {
|
||
return ShavedQuestion{
|
||
Id: question.Id,
|
||
Title: question.Title,
|
||
Description: question.Description,
|
||
Type: question.Type,
|
||
Required: false,
|
||
Page: question.Page,
|
||
Content: question.Content,
|
||
}
|
||
}
|
||
|
||
func dao2dtoQuiz(quiz model.Quiz) ShavedQuiz {
|
||
|
||
return ShavedQuiz{
|
||
Fingerprinting: quiz.Fingerprinting,
|
||
Repeatable: quiz.Repeatable,
|
||
Name: quiz.Name,
|
||
Config: quiz.Config,
|
||
Limit: quiz.Limit,
|
||
DueTo: quiz.DueTo,
|
||
TimeOfPassing: quiz.TimeOfPassing,
|
||
Pausable: quiz.Pausable,
|
||
Status: quiz.Status,
|
||
}
|
||
}
|
||
|
||
// MB Size constants
|
||
const (
|
||
MB = 1 << 20
|
||
filePrefix = "file:"
|
||
)
|
||
|
||
type PutAnswersResponse struct {
|
||
FileIDMap map[uint64]string `json:"fileIDMap"`
|
||
Stored []uint64 `json:"stored"`
|
||
}
|
||
|
||
// todo не отдавать ответы с типом start но сохранять брать из контента ответа
|
||
// поле бул также в GetQuizdata не отдавать его, но по запросам идет GetQuizdata получаем данные квиза
|
||
// аотом отправляем ответы в PutAnswers и сохраяняем их подумать как делать
|
||
func (s *Service) PutAnswersOnePiece(c *fiber.Ctx) error {
|
||
cs, ok := c.Context().Value(middleware.ContextKey(middleware.SessionKey)).(string)
|
||
if !ok {
|
||
return c.Status(fiber.StatusUnauthorized).SendString("no session in cookie")
|
||
}
|
||
|
||
hlogger := log_mw.ExtractLogger(c)
|
||
|
||
form, err := c.MultipartForm()
|
||
if err != nil || form == nil || form.File == nil {
|
||
return c.Status(fiber.StatusBadRequest).SendString("expecting multipart form file")
|
||
}
|
||
|
||
answersStr := form.Value["answers"]
|
||
if len(answersStr) == 0 {
|
||
return c.Status(fiber.StatusFailedDependency).SendString("no answers provided")
|
||
}
|
||
|
||
var (
|
||
answersRaw, answers, trueRes []model.Answer
|
||
errs []error
|
||
)
|
||
|
||
deviceType := c.Get("DeviceType")
|
||
os := c.Get("OS")
|
||
browser := c.Get("Browser")
|
||
ip := c.IP()
|
||
device := c.Get("Device")
|
||
referrer := c.Get("Referer")
|
||
|
||
if err := json.Unmarshal([]byte(answersStr[0]), &answersRaw); err != nil {
|
||
return c.Status(fiber.StatusBadRequest).SendString("not valid answers string")
|
||
}
|
||
|
||
quizID, ok := form.Value["qid"]
|
||
if !ok {
|
||
return c.Status(fiber.StatusFailedDependency).SendString("no quiz id provided")
|
||
}
|
||
|
||
fp := ""
|
||
if cfp := c.Cookies(fingerprintCookie); cfp != "" {
|
||
fp = cfp
|
||
}
|
||
|
||
quiz, err := s.dal.QuizRepo.GetQuizByQid(c.Context(), quizID[0])
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("can not get quiz")
|
||
}
|
||
|
||
fileIDMap := make(map[uint64]string)
|
||
|
||
for _, ans := range answersRaw {
|
||
|
||
if quiz.Status == model.StatusAI {
|
||
final := false
|
||
if finalStr, exists := form.Value["final"]; exists && len(finalStr) > 0 {
|
||
parsedFinal, err := strconv.ParseBool(finalStr[0])
|
||
if err != nil {
|
||
return c.Status(fiber.StatusBadRequest).SendString("invalid final value")
|
||
}
|
||
final = parsedFinal
|
||
}
|
||
|
||
question, err := s.dal.QuestionRepo.GetQuestionListByIDs(c.Context(), []int32{int32(ans.QuestionId)})
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("can not get questions")
|
||
}
|
||
|
||
if len(question) == 0 {
|
||
return c.Status(fiber.StatusNotFound).SendString("no questions found")
|
||
}
|
||
|
||
questionText, err := s.aiClient.SendAnswerer(final, question[0].Type, ans.Content, cs)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(fmt.Sprintf("failed send answer to ai, err: %s", err.Error()))
|
||
}
|
||
|
||
_, err = s.dal.QuestionRepo.CreateQuestion(c.Context(), &model.Question{
|
||
QuizId: quiz.Id,
|
||
Title: " ",
|
||
Type: model.TypeText,
|
||
Session: cs,
|
||
Description: questionText,
|
||
})
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString(fmt.Sprintf("failed create question type ai, err: %s", err.Error()))
|
||
}
|
||
}
|
||
|
||
ans.DeviceType = deviceType
|
||
ans.OS = os
|
||
ans.Browser = browser
|
||
ans.IP = ip
|
||
ans.Device = device
|
||
if strings.HasPrefix(ans.Content, filePrefix) {
|
||
filekey := strings.TrimPrefix(ans.Content, filePrefix)
|
||
filenameparts := strings.Split(filekey, ".")
|
||
filetail := filenameparts[len(filenameparts)-1]
|
||
fileparts := form.File[filekey]
|
||
|
||
if len(fileparts) == 0 {
|
||
errs = append(errs, fmt.Errorf("no parts for file: %s", filekey))
|
||
continue
|
||
}
|
||
|
||
r, err := fileparts[0].Open()
|
||
if err != nil {
|
||
errs = append(errs, fmt.Errorf("can not open part for file: %s", filekey))
|
||
continue
|
||
}
|
||
|
||
fname := fmt.Sprintf("%s.%s", xid.New().String(), filetail)
|
||
if err := s.store.PutAnswer(c.Context(), r, quizID[0], fname, ans.QuestionId, fileparts[0].Size); err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("can not upload file answers")
|
||
}
|
||
ans.Content = fname
|
||
|
||
fileIDMap[ans.QuestionId] = fname
|
||
}
|
||
|
||
ans.Session = cs
|
||
ans.QuizId = quiz.Id
|
||
ans.CreatedAt = time.Now()
|
||
answers = append(answers, ans)
|
||
if ans.Result {
|
||
content := model.ResultContent{}
|
||
err := json.Unmarshal([]byte(ans.Content), &content)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("error unmarshalling answer content: " + err.Error())
|
||
}
|
||
ans.Email = content.Email
|
||
|
||
hlogger.Emit(models.InfoContactForm{
|
||
KeyOS: os,
|
||
KeyDevice: device,
|
||
KeyDeviceType: deviceType,
|
||
KeyBrowser: browser,
|
||
CtxQuiz: quizID[0],
|
||
CtxQuizID: int64(quiz.Id),
|
||
CtxReferrer: referrer,
|
||
CtxQuestionID: int64(ans.QuestionId),
|
||
CtxIDInt: int64(ans.Id),
|
||
CtxSession: cs,
|
||
})
|
||
|
||
s.workerSendClientCh <- ans
|
||
trueRes = append(trueRes, ans)
|
||
}
|
||
}
|
||
|
||
quizConfig := model.QuizConfig{}
|
||
err = json.Unmarshal([]byte(quiz.Config), &quizConfig)
|
||
if err != nil {
|
||
return c.Status(fiber.StatusInternalServerError).SendString("can not unmarshal quiz config")
|
||
}
|
||
|
||
if quizConfig.Mailing.When == "email" && len(trueRes) > 0 {
|
||
s.workerRespondentCh <- trueRes
|
||
}
|
||
|
||
stored, ers := s.dal.AnswerRepo.CreateAnswers(c.Context(), answers, cs, fp, quiz.Id)
|
||
if len(ers) != 0 {
|
||
for _, err := range ers {
|
||
if strings.Contains(err.Error(), "duplicate key value") {
|
||
return c.Status(fiber.StatusAlreadyReported).SendString("User has already passed the quiz")
|
||
}
|
||
}
|
||
|
||
return c.Status(fiber.StatusInternalServerError).SendString("some errors are casualted: " + fmt.Sprint(ers))
|
||
}
|
||
var questionIDs []uint64
|
||
for _, ans := range stored {
|
||
questionIDs = append(questionIDs, ans.QuestionId)
|
||
if ans.Result {
|
||
hlogger.Emit(models.InfoResult{
|
||
KeyOS: os,
|
||
KeyDevice: device,
|
||
KeyDeviceType: deviceType,
|
||
KeyBrowser: browser,
|
||
CtxQuiz: quizID[0],
|
||
CtxQuizID: int64(quiz.Id),
|
||
CtxReferrer: referrer,
|
||
CtxQuestionID: int64(ans.QuestionId),
|
||
CtxIDInt: int64(ans.Id),
|
||
CtxSession: cs,
|
||
})
|
||
continue
|
||
}
|
||
hlogger.Emit(models.InfoAnswer{
|
||
KeyOS: os,
|
||
KeyDevice: device,
|
||
KeyDeviceType: deviceType,
|
||
KeyBrowser: browser,
|
||
CtxQuiz: quizID[0],
|
||
CtxQuizID: int64(quiz.Id),
|
||
CtxReferrer: referrer,
|
||
CtxQuestionID: int64(ans.QuestionId),
|
||
CtxIDInt: int64(ans.Id),
|
||
CtxSession: cs,
|
||
})
|
||
}
|
||
|
||
response := PutAnswersResponse{
|
||
FileIDMap: fileIDMap,
|
||
Stored: questionIDs,
|
||
}
|
||
|
||
return c.Status(fiber.StatusOK).JSON(response)
|
||
}
|
||
|
||
func (s *Service) MiniPart(ctx *fiber.Ctx) error {
|
||
qid := ctx.Query("q")
|
||
if qid == "" {
|
||
return ctx.Status(fiber.StatusBadRequest).SendString("qid is nil")
|
||
}
|
||
ctx.Cookie(&fiber.Cookie{
|
||
Name: "quizFrom",
|
||
Value: qid,
|
||
})
|
||
|
||
userID, err := s.dal.AccountRepo.GetQidOwner(ctx.Context(), qid)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
|
||
shifr, err := s.encrypt.EncryptStr(userID)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
|
||
ctx.Cookie(&fiber.Cookie{
|
||
Name: "quizUser",
|
||
Value: url.QueryEscape(string(shifr)),
|
||
})
|
||
|
||
return ctx.Redirect(s.redirectURl, fiber.StatusFound)
|
||
}
|
||
|
||
const marker = "window.__CONFIG__"
|
||
|
||
func (s *Service) UploadScriptTemplate(ctx *fiber.Ctx) error {
|
||
fileHeader, err := ctx.FormFile("pub.js")
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusBadRequest).SendString("failed to get file: " + err.Error())
|
||
}
|
||
|
||
file, err := fileHeader.Open()
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString("failed to open file: " + err.Error())
|
||
}
|
||
defer file.Close()
|
||
|
||
content, err := io.ReadAll(file)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString("failed to read file: " + err.Error())
|
||
}
|
||
|
||
s.script.mu.Lock()
|
||
s.script.full = content
|
||
s.script.mu.Unlock()
|
||
|
||
return ctx.SendStatus(fiber.StatusNoContent)
|
||
}
|
||
|
||
// возвращаем файл pub.js начало marker = маршаленные данные структуры Props и s.script.full
|
||
func (s *Service) GetScriptTemplate(ctx *fiber.Ctx) error {
|
||
cs, ok := ctx.Context().Value(middleware.ContextKey(middleware.SessionKey)).(string)
|
||
if !ok {
|
||
return ctx.Status(fiber.StatusUnauthorized).SendString("no session in cookie")
|
||
}
|
||
|
||
qID := ctx.Params("qID")
|
||
if qID == "" {
|
||
return ctx.Status(fiber.StatusBadRequest).SendString("missing qID in path")
|
||
}
|
||
|
||
hlogger := log_mw.ExtractLogger(ctx)
|
||
|
||
quiz, err := s.dal.QuizRepo.GetQuizByQid(ctx.Context(), qID)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
|
||
if quiz.Status != model.StatusStart && quiz.Status != model.StatusAI {
|
||
return ctx.Status(fiber.StatusLocked).SendString("quiz is inactive")
|
||
}
|
||
|
||
if quiz.DueTo < uint64(time.Now().Unix()) && quiz.DueTo > 0 {
|
||
return ctx.Status(fiber.StatusGone).SendString("quiz timeouted")
|
||
}
|
||
|
||
account, err := s.dal.AccountRepo.GetAccountByID(ctx.Context(), quiz.AccountId)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString("can`t get account by quiz.AccountId")
|
||
}
|
||
|
||
showBadge := true
|
||
if priv, ok := account.Privileges["squizHideBadge"]; ok {
|
||
expiration := priv.CreatedAt.Add(time.Duration(priv.Amount) * 24 * time.Hour)
|
||
|
||
if time.Now().Before(expiration) {
|
||
showBadge = false
|
||
}
|
||
}
|
||
|
||
var questions []model.Question
|
||
var cnt uint64
|
||
|
||
if quiz.Status == model.StatusAI {
|
||
questions, cnt, err = s.dal.QuestionRepo.GetQuestionsAI(ctx.Context(), int64(quiz.Id), cs, 100_000, 0, 0)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
} else {
|
||
questions, cnt, err = s.dal.QuestionRepo.GetQuestionList(
|
||
ctx.Context(),
|
||
100_000, 0, 0, 0, quiz.Id, false, false, "", "", 0,
|
||
)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(err.Error())
|
||
}
|
||
}
|
||
|
||
utmData := model.UTMSavingMap{
|
||
"utm_content": ctx.Query("utm_content"),
|
||
"utm_medium": ctx.Query("utm_medium"),
|
||
"utm_campaign": ctx.Query("utm_campaign"),
|
||
"utm_source": ctx.Query("utm_source"),
|
||
"utm_term": ctx.Query("utm_term"),
|
||
"utm_referrer": ctx.Query("utm_referrer"),
|
||
"roistat": ctx.Query("roistat"),
|
||
"referrer": ctx.Query("referrer"),
|
||
"openstat_service": ctx.Query("openstat_service"),
|
||
"openstat_campaign": ctx.Query("openstat_campaign"),
|
||
"openstat_ad": ctx.Query("openstat_ad"),
|
||
"openstat_source": ctx.Query("openstat_source"),
|
||
"from": ctx.Query("from"),
|
||
"gclientid": ctx.Query("gclientid"),
|
||
"_ym_uid": ctx.Query("_ym_uid"),
|
||
"_ym_counter": ctx.Query("_ym_counter"),
|
||
"gclid": ctx.Query("gclid"),
|
||
"yclid": ctx.Query("yclid"),
|
||
"fbclid": ctx.Query("fbclid"),
|
||
}
|
||
|
||
deviceType := ctx.Get("DeviceType")
|
||
os := ctx.Get("OS")
|
||
browser := ctx.Get("Browser")
|
||
ip := ctx.IP()
|
||
device := ctx.Get("Device")
|
||
referrer := ctx.Get("Referer")
|
||
fp := ""
|
||
if cfp := ctx.Cookies(fingerprintCookie); cfp != "" {
|
||
fp = cfp
|
||
}
|
||
|
||
if len(questions) == 0 {
|
||
return ctx.Status(fiber.StatusNotFound).SendString("question not found")
|
||
}
|
||
|
||
answers, errs := s.dal.AnswerRepo.CreateAnswers(ctx.Context(), []model.Answer{{
|
||
Content: "start",
|
||
QuestionId: questions[0].Id,
|
||
QuizId: quiz.Id,
|
||
Start: true,
|
||
DeviceType: deviceType,
|
||
Device: device,
|
||
Browser: browser,
|
||
IP: ip,
|
||
OS: os,
|
||
Utm: utmData,
|
||
}}, cs, fp, quiz.Id)
|
||
if len(errs) != 0 {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString(errs[0].Error())
|
||
}
|
||
|
||
hlogger.Emit(models.InfoQuizOpen{
|
||
KeyOS: os,
|
||
KeyDevice: device,
|
||
KeyDeviceType: deviceType,
|
||
KeyBrowser: browser,
|
||
CtxQuiz: qID,
|
||
CtxQuizID: int64(quiz.Id),
|
||
CtxReferrer: referrer,
|
||
CtxIDInt: int64(answers[0].Id),
|
||
CtxSession: cs,
|
||
})
|
||
|
||
props := dao2dtoProps(quiz, questions, showBadge, cnt)
|
||
|
||
propsJSON, err := json.Marshal(props)
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString("failed to marshal props")
|
||
}
|
||
|
||
propsJSONString, err := json.Marshal(string(propsJSON))
|
||
if err != nil {
|
||
return ctx.Status(fiber.StatusInternalServerError).SendString("failed to escape props JSON")
|
||
}
|
||
|
||
s.script.mu.RLock()
|
||
defer s.script.mu.RUnlock()
|
||
|
||
script := fmt.Sprintf("%s = %s;\n%s", marker, string(propsJSONString), s.script.full)
|
||
|
||
ctx.Set("Content-Disposition", `attachment; filename="pub.js"`)
|
||
return ctx.Type("application/javascript").Status(fiber.StatusOK).SendString(script)
|
||
}
|