262 lines
6.9 KiB
V
262 lines
6.9 KiB
V
module repository
|
||
|
||
import models
|
||
import db.pg
|
||
|
||
// todo дообработать ошибки сейчас что то не возвращаются они
|
||
|
||
pub struct Repo {
|
||
pub mut:
|
||
db map[string]string
|
||
pg_db pg.DB
|
||
data_set_map map[string]models.Question
|
||
}
|
||
|
||
pub fn (mut r Repo) connect_to_db(cfg pg.Config) ! {
|
||
r.pg_db = pg.connect(cfg)!
|
||
println('Connected to the database successfully.')
|
||
}
|
||
|
||
|
||
pub fn (mut r Repo)save_state(chat_id string,state string) {
|
||
r.db[chat_id]=state
|
||
println(r.db)
|
||
}
|
||
|
||
// pub fn (mut r Repo)get_state(chat_id string)!string{
|
||
// if chat_id in r.db {
|
||
// return r.db[chat_id]
|
||
// }
|
||
// return error('empty key')
|
||
// }
|
||
|
||
pub fn (mut r Repo)get_next_que_data(state string)!models.Question{
|
||
if state in r.data_set_map {
|
||
return r.data_set_map[state]
|
||
}
|
||
return error('empty')
|
||
}
|
||
|
||
// todo допилить работу со стейтами, надо понять как без telegram id стейт получать и обновлять
|
||
// методы QuizRespondentState
|
||
// вызывается при /start, создает запись
|
||
pub fn (mut r Repo) create_state(state models.RespondentState) !i64 {
|
||
state_id := sql r.pg_db {
|
||
insert state into models.RespondentState
|
||
} or {
|
||
return error('Failed insert state: $err')
|
||
}
|
||
return state_id
|
||
}
|
||
|
||
// вызывать при любом другом, кроме вопроса с типом result
|
||
pub fn (mut r Repo) update_state(id i64, new_state i64) ! {
|
||
sql r.pg_db {
|
||
update models.RespondentState set state = new_state where id == id
|
||
} or {
|
||
return error('Failed update state: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (mut r Repo) get_state(state_id i64)!models.RespondentState{
|
||
result := sql r.pg_db {
|
||
select from models.RespondentState where id == state_id
|
||
}or{
|
||
return error('error getting state from db')
|
||
}
|
||
|
||
if result.len == 0{
|
||
return error('state not found')
|
||
}
|
||
|
||
return result[0]
|
||
}
|
||
|
||
// выставляется при типе вопроса result = true
|
||
pub fn (mut r Repo) finish_state(id i64) ! {
|
||
sql r.pg_db {
|
||
update models.RespondentState set finish = true where id == id
|
||
} or {
|
||
return error('Failed finish state: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (mut r Repo) get_state_by_tg_quiz_id(tg_id int,quiz_id i64)!models.RespondentState {
|
||
result := sql r.pg_db {
|
||
select from models.RespondentState where quiz_id == quiz_id && telegram_id == tg_id && finish == false
|
||
}or{
|
||
return error('error getting state from db')
|
||
}
|
||
|
||
if result.len == 0{
|
||
return error('state not found')
|
||
}
|
||
|
||
return result[0]
|
||
}
|
||
|
||
pub fn (mut r Repo)get_state_by_tg_quiz_id_finish_true(tg_id int,quiz_id i64)!int {
|
||
result := sql r.pg_db {
|
||
select from models.RespondentState where quiz_id == quiz_id && telegram_id == tg_id && finish == true
|
||
}or{
|
||
return error('error getting state from db')
|
||
}
|
||
|
||
if result.len == 0{
|
||
return 0
|
||
}
|
||
|
||
return result.len
|
||
}
|
||
|
||
// методы с question
|
||
// получение вопроса по id
|
||
pub fn (mut r Repo) get_question_by_id(id i64) !models.QuizQuestion {
|
||
question := sql r.pg_db {
|
||
select from models.QuizQuestion where id == id && deleted == false
|
||
} or {
|
||
return error('Question not found')
|
||
}
|
||
|
||
if question.len==0{
|
||
return error('Question not found')
|
||
}
|
||
|
||
return question[0]
|
||
}
|
||
|
||
pub fn (mut r Repo) get_questions_by_quiz_id(quiz_id i64) ![]models.QuizQuestion {
|
||
question := sql r.pg_db {
|
||
select from models.QuizQuestion where quiz_id == quiz_id && deleted == false order by page
|
||
} or {
|
||
return error('question not found for quiz_id')
|
||
}
|
||
|
||
if question.len==0{
|
||
return error("not found")
|
||
}
|
||
|
||
return question
|
||
}
|
||
|
||
pub fn (mut r Repo) get_all_results(id i64)![]models.QuizQuestion {
|
||
result := sql r.pg_db {
|
||
select from models.QuizQuestion where quiz_id == id && question_type == models.question_type_result.str() && deleted ==false
|
||
} or {
|
||
return error('question with type result not found for quiz_id')
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// методы Quiz
|
||
|
||
pub fn (mut r Repo) get_quiz(quiz_id i64)!models.Quiz {
|
||
result := sql r.pg_db{
|
||
select from models.Quiz where id == quiz_id && deleted == false && archived == false
|
||
}or{
|
||
return error('QUIZ not found')
|
||
}
|
||
|
||
if result.len == 0{
|
||
return error('QUIZ not found')
|
||
}
|
||
|
||
return result[0]
|
||
}
|
||
|
||
// методы TelegramIntegration
|
||
// получение интеграции по id
|
||
pub fn (mut r Repo) get_integration_by_id(id i64) !models.TelegramIntegration {
|
||
integration := sql r.pg_db {
|
||
select from models.TelegramIntegration where id == id && deleted == false limit 1
|
||
} or {
|
||
return error('Integration not found')
|
||
}
|
||
|
||
if integration.len == 0 {
|
||
return error('Integration not found')
|
||
}
|
||
|
||
return integration[0]
|
||
}
|
||
|
||
// создает запись о интеграции
|
||
pub fn (mut r Repo) create_integration(integration models.TelegramIntegration) !int {
|
||
integration_id := sql r.pg_db {
|
||
insert integration into models.TelegramIntegration
|
||
} or {
|
||
return error('Failed create integration: $err')
|
||
}
|
||
return integration_id
|
||
}
|
||
|
||
// обновляет токен бота
|
||
pub fn (mut r Repo) update_bot_token(id i64, new_token string) ! {
|
||
sql r.pg_db {
|
||
update models.TelegramIntegration set bot_token = new_token where id == id && deleted == false
|
||
} or {
|
||
return error('Failed to update bot token: $err')
|
||
}
|
||
}
|
||
|
||
// обновляет поля ниже токена
|
||
pub fn (mut r Repo) update_integration_fields(id i64, integration models.TelegramIntegration) ! {
|
||
sql r.pg_db {
|
||
update models.TelegramIntegration set repeatable = integration.repeatable, bot_name = integration.bot_name, deleted = integration.deleted where id == id && deleted == false
|
||
} or {
|
||
return error('Failed update integration fields: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (mut r Repo)soft_delete_integration(quiz_id i64)!{
|
||
sql r.pg_db{
|
||
update models.TelegramIntegration set deleted = true where quiz_id == quiz_id
|
||
}or{
|
||
return error('Failed soft delete integration: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (mut r Repo) update_bot_name(bot_id i64,name string)!{
|
||
sql r.pg_db {
|
||
update models.TelegramIntegration set bot_name = name where id == bot_id
|
||
}or{
|
||
return error('Failed update bot name: $err')
|
||
}
|
||
}
|
||
|
||
// методы telegram_user_quiz_result
|
||
pub fn (mut r Repo) create_record_user_result(data models.TelegramUserQuizResult) ! {
|
||
sql r.pg_db {
|
||
insert data into models.TelegramUserQuizResult
|
||
} or {
|
||
return error('Failed create record user result: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (mut r Repo) update_record_user_result(data models.TelegramUserQuizResult)!{
|
||
sql r.pg_db {
|
||
update models.TelegramUserQuizResult set current_field = data.current_field,user_answer = data.user_answer, state = data.state,iter = data.iter where session == data.session
|
||
}or{
|
||
return error('Failed update bot name: $err')
|
||
}
|
||
}
|
||
|
||
pub fn (r Repo) get_record_user_result(ses string)!models.TelegramUserQuizResult {
|
||
result := sql r.pg_db{
|
||
select from models.TelegramUserQuizResult where session == ses && state == models.user_result_tg_status_in_progress.str()
|
||
}or{
|
||
return error('record user result not found')
|
||
}
|
||
|
||
if result.len == 0{
|
||
return error('record user result not found')
|
||
}
|
||
|
||
return result[0]
|
||
}
|
||
|
||
// закрываем соединение с бд
|
||
pub fn (mut r Repo)stop_db(){
|
||
r.pg_db.close()
|
||
} |