976 lines
31 KiB
Dart
976 lines
31 KiB
Dart
import 'dart:convert';
|
|
|
|
import 'package:postgres/postgres.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
|
|
import 'question_source_mix.dart';
|
|
import 'trading/market_history_config.dart';
|
|
import 'trading/prospective_answer_scoring.dart';
|
|
import 'trading/guess_score_store.dart';
|
|
import 'trading/prospective_guess_assignments_db.dart';
|
|
import 'trading/prospective_guess_selection.dart';
|
|
import 'trading/user_trading_state_db.dart';
|
|
|
|
/// Postgres access for the questions table.
|
|
class QuestionsDb {
|
|
QuestionsDb(this._connection);
|
|
|
|
final Connection _connection;
|
|
|
|
Connection get connection => _connection;
|
|
|
|
static const Uuid _uuid = Uuid();
|
|
|
|
Future<void> ensureUserExists(String firebaseUid) async {
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
INSERT INTO users (firebase_uid)
|
|
VALUES (@uid)
|
|
ON CONFLICT (firebase_uid) DO NOTHING
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': firebaseUid},
|
|
);
|
|
}
|
|
|
|
static const String _questionsSelectColumns = '''
|
|
q.id, q.assigned_user_id, q.question_text, q.user_response, q.correct_answer,
|
|
q.created_at, q.modified_at, q.source_tag, q.pipeline_key, q.pipeline_step,
|
|
q.metadata, q.user_response_text''';
|
|
|
|
static const String _unansweredQuestionsJoin = '''
|
|
FROM questions q
|
|
LEFT JOIN market_history_prospective_assignments a
|
|
ON a.question_id = q.id
|
|
AND a.assigned_user_id = q.assigned_user_id
|
|
AND a.status = 'pending'
|
|
WHERE q.assigned_user_id = @uid AND q.user_response IS NULL''';
|
|
|
|
static const String _unansweredQuestionsOrder = '''
|
|
ORDER BY COALESCE(a.view_order_at, q.created_at) ASC, q.id ASC''';
|
|
|
|
/// Latest unanswered question for [assignedUserId], or null if none.
|
|
Future<Map<String, dynamic>?> findUnansweredQuestion(
|
|
String assignedUserId,
|
|
) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT $_questionsSelectColumns
|
|
$_unansweredQuestionsJoin
|
|
$_unansweredQuestionsOrder
|
|
LIMIT 1
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
return _rowFromResult(result.first);
|
|
}
|
|
|
|
/// All unanswered questions for [assignedUserId], oldest first.
|
|
Future<List<Map<String, dynamic>>> listUnansweredQuestions(
|
|
String assignedUserId,
|
|
) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT $_questionsSelectColumns
|
|
$_unansweredQuestionsJoin
|
|
$_unansweredQuestionsOrder
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
return result.map(_rowFromResult).toList();
|
|
}
|
|
|
|
/// FIFO head after deferring [deferredQuestionId] (falls back to sole item).
|
|
Future<Map<String, dynamic>?> findNextUnansweredAfterDefer({
|
|
required String assignedUserId,
|
|
required String deferredQuestionId,
|
|
}) async {
|
|
final List<Map<String, dynamic>> rows =
|
|
await listUnansweredQuestions(assignedUserId);
|
|
if (rows.isEmpty) {
|
|
return null;
|
|
}
|
|
for (final Map<String, dynamic> row in rows) {
|
|
if (row['id'] != deferredQuestionId) {
|
|
return row;
|
|
}
|
|
}
|
|
return rows.first;
|
|
}
|
|
|
|
/// Deletes every spelling pipeline question row for [firebaseUid].
|
|
Future<void> deleteAllSpellingQuestionsForUser(String firebaseUid) async {
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
DELETE FROM questions
|
|
WHERE assigned_user_id = @uid
|
|
AND (
|
|
pipeline_key = 'spelling'
|
|
OR source_tag LIKE 'spelling:%'
|
|
)
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': firebaseUid},
|
|
);
|
|
}
|
|
|
|
/// Clears spelling pipeline state when [assignedUserId] is on that branch.
|
|
Future<void> clearSpellingPipelineState(String assignedUserId) async {
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
DELETE FROM user_pipeline_state
|
|
WHERE assigned_user_id = @uid
|
|
AND pipeline_key = 'spelling'
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
}
|
|
|
|
/// Deletes every guess-game question row for [firebaseUid].
|
|
///
|
|
/// Assignments and answer snapshots referencing these rows cascade away.
|
|
Future<void> deleteAllProspectiveGuessQuestionsForUser(
|
|
String firebaseUid,
|
|
) async {
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
DELETE FROM questions
|
|
WHERE assigned_user_id = @uid
|
|
AND source_tag = 'market_history:prospective'
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': firebaseUid},
|
|
);
|
|
}
|
|
|
|
/// Removes an unanswered question owned by [assignedUserId].
|
|
Future<void> deleteUnansweredQuestion({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
}) async {
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
DELETE FROM questions
|
|
WHERE id = @id::uuid
|
|
AND assigned_user_id = @uid
|
|
AND user_response IS NULL
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Records [userResponse] for an unanswered question owned by [assignedUserId].
|
|
///
|
|
/// When the answered question metadata includes `prospective_question_id`,
|
|
/// also snapshots the answer into `market_history_prospective_answers`.
|
|
Future<Map<String, dynamic>?> submitAnswer({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
num? userResponse,
|
|
String? userResponseText,
|
|
}) async {
|
|
if (userResponse == null && userResponseText == null) {
|
|
throw ArgumentError('userResponse or userResponseText is required');
|
|
}
|
|
|
|
num effectiveResponse = userResponse ?? 0;
|
|
String? textToStore = userResponseText?.trim();
|
|
|
|
if (textToStore != null) {
|
|
final Map<String, dynamic>? existing = await findQuestionById(
|
|
questionId: questionId,
|
|
assignedUserId: assignedUserId,
|
|
);
|
|
if (existing == null || resolveSourceId(existing) != 'spelling') {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
final DateTime now = DateTime.now().toUtc();
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
UPDATE questions
|
|
SET user_response = @user_response,
|
|
user_response_text = @user_response_text,
|
|
modified_at = @modified_at
|
|
WHERE id = @id::uuid
|
|
AND assigned_user_id = @uid
|
|
AND user_response IS NULL
|
|
RETURNING id, assigned_user_id, question_text, user_response, correct_answer,
|
|
created_at, modified_at, source_tag, pipeline_key, pipeline_step,
|
|
metadata, user_response_text
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
'user_response': effectiveResponse,
|
|
'user_response_text': textToStore,
|
|
'modified_at': now,
|
|
},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
final Map<String, dynamic> updated = _rowFromResult(result.first);
|
|
if (resolveSourceId(updated) == 'market_history') {
|
|
await _recordProspectiveAnswer(updated);
|
|
await ProspectiveGuessAssignmentsDb(_connection).markAnsweredByQuestionId(
|
|
questionId: questionId,
|
|
answeredAt: now,
|
|
);
|
|
await _gradeProspectiveAnswerIfNeeded(updated);
|
|
}
|
|
return updated;
|
|
}
|
|
|
|
/// Answered questions grouped by client [resolveSourceId].
|
|
Future<Map<String, int>> countDeliveredBySourceId(String assignedUserId) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT source_tag, pipeline_key
|
|
FROM questions
|
|
WHERE assigned_user_id = @uid AND user_response IS NOT NULL
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
|
|
final Map<String, int> counts = <String, int>{};
|
|
for (final ResultRow row in result) {
|
|
final String sourceId = resolveSourceId(<String, dynamic>{
|
|
'sourceTag': row[0],
|
|
'pipelineKey': row[1],
|
|
});
|
|
counts[sourceId] = (counts[sourceId] ?? 0) + 1;
|
|
}
|
|
return counts;
|
|
}
|
|
|
|
/// Mix-ordered head of the unanswered queue for display after an answer or panel open.
|
|
Future<Map<String, dynamic>?> findHeadUnansweredForMix(
|
|
String assignedUserId, {
|
|
required Map<String, int> effectiveMixPercent,
|
|
Map<String, int>? deliveredCounts,
|
|
String? afterAnsweringSourceId,
|
|
Set<String>? allowedSourceIds,
|
|
}) async {
|
|
List<Map<String, dynamic>> rows =
|
|
await listUnansweredQuestions(assignedUserId);
|
|
if (allowedSourceIds != null) {
|
|
rows = filterByAllowedSources(rows, allowedSourceIds);
|
|
}
|
|
if (rows.isEmpty) {
|
|
return null;
|
|
}
|
|
|
|
if (afterAnsweringSourceId == 'spelling') {
|
|
for (final Map<String, dynamic> row in rows) {
|
|
if (resolveSourceId(row) == 'spelling') {
|
|
return row;
|
|
}
|
|
}
|
|
}
|
|
|
|
final Map<String, int> delivered =
|
|
deliveredCounts ?? await countDeliveredBySourceId(assignedUserId);
|
|
final String preferred = QuestionSourceMix.pickNextSourceId(
|
|
effectiveMixPercent: effectiveMixPercent,
|
|
deliveredCounts: delivered,
|
|
);
|
|
final List<Map<String, dynamic>> ordered =
|
|
QuestionSourceMix.orderUnansweredByPreferredSource(
|
|
rows,
|
|
preferredSourceId: preferred,
|
|
);
|
|
return ordered.first;
|
|
}
|
|
|
|
/// Full unanswered list ordered for panel display (preferred mix source first).
|
|
Future<List<Map<String, dynamic>>> listUnansweredOrderedForMix(
|
|
String assignedUserId, {
|
|
required Map<String, int> effectiveMixPercent,
|
|
Set<String>? allowedSourceIds,
|
|
}) async {
|
|
List<Map<String, dynamic>> rows =
|
|
await listUnansweredQuestions(assignedUserId);
|
|
if (allowedSourceIds != null) {
|
|
rows = filterByAllowedSources(rows, allowedSourceIds);
|
|
}
|
|
if (rows.isEmpty) {
|
|
return rows;
|
|
}
|
|
final Map<String, int> delivered =
|
|
await countDeliveredBySourceId(assignedUserId);
|
|
final String preferred = QuestionSourceMix.pickNextSourceId(
|
|
effectiveMixPercent: effectiveMixPercent,
|
|
deliveredCounts: delivered,
|
|
);
|
|
return QuestionSourceMix.orderUnansweredByPreferredSource(
|
|
rows,
|
|
preferredSourceId: preferred,
|
|
);
|
|
}
|
|
|
|
/// Keeps only rows whose [resolveSourceId] is in [allowedSourceIds].
|
|
static List<Map<String, dynamic>> filterByAllowedSources(
|
|
List<Map<String, dynamic>> rows,
|
|
Set<String> allowedSourceIds,
|
|
) {
|
|
if (allowedSourceIds.isEmpty) {
|
|
return <Map<String, dynamic>>[];
|
|
}
|
|
return rows
|
|
.where(
|
|
(Map<String, dynamic> row) =>
|
|
allowedSourceIds.contains(resolveSourceId(row)),
|
|
)
|
|
.toList(growable: false);
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> findQuestionById({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
}) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT id, assigned_user_id, question_text, user_response, correct_answer,
|
|
created_at, modified_at, source_tag, pipeline_key, pipeline_step,
|
|
metadata, user_response_text
|
|
FROM questions
|
|
WHERE id = @id::uuid AND assigned_user_id = @uid
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
return _rowFromResult(result.first);
|
|
}
|
|
|
|
/// All Firebase UIDs that have a profile row (pipeline targets).
|
|
Future<List<String>> listAllUserFirebaseUids() async {
|
|
final Result result = await _connection.execute(
|
|
'SELECT firebase_uid FROM users ORDER BY updated_at DESC',
|
|
);
|
|
return result
|
|
.map((ResultRow row) => row[0]! as String)
|
|
.toList();
|
|
}
|
|
|
|
Future<Map<String, dynamic>?> getPipelineState(String assignedUserId) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT pipeline_key, step, context, updated_at
|
|
FROM user_pipeline_state
|
|
WHERE assigned_user_id = @uid
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
final ResultRow row = result.first;
|
|
final Object? contextRaw = row[2];
|
|
final Map<String, dynamic> context = contextRaw is Map<String, dynamic>
|
|
? contextRaw
|
|
: jsonDecode(contextRaw.toString()) as Map<String, dynamic>;
|
|
return <String, dynamic>{
|
|
'assignedUserId': assignedUserId,
|
|
'pipelineKey': row[0]! as String,
|
|
'step': row[1]! as String,
|
|
'context': context,
|
|
'updatedAt': (row[3]! as DateTime).toIso8601String(),
|
|
};
|
|
}
|
|
|
|
Future<void> upsertPipelineState({
|
|
required String assignedUserId,
|
|
required String pipelineKey,
|
|
required String step,
|
|
required Map<String, dynamic> context,
|
|
}) async {
|
|
await ensureUserExists(assignedUserId);
|
|
final DateTime now = DateTime.now().toUtc();
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
INSERT INTO user_pipeline_state (
|
|
assigned_user_id, pipeline_key, step, context, updated_at
|
|
) VALUES (
|
|
@uid, @pipeline_key, @step, @context::jsonb, @updated_at
|
|
)
|
|
ON CONFLICT (assigned_user_id) DO UPDATE SET
|
|
pipeline_key = EXCLUDED.pipeline_key,
|
|
step = EXCLUDED.step,
|
|
context = EXCLUDED.context,
|
|
updated_at = EXCLUDED.updated_at
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'uid': assignedUserId,
|
|
'pipeline_key': pipelineKey,
|
|
'step': step,
|
|
'context': jsonEncode(context),
|
|
'updated_at': now,
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Moves an unanswered question to the end of the user's queue.
|
|
Future<Map<String, dynamic>?> deferQuestion({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
}) async {
|
|
final DateTime now = DateTime.now().toUtc();
|
|
final ProspectiveGuessAssignmentsDb assignmentsDb =
|
|
ProspectiveGuessAssignmentsDb(_connection);
|
|
final bool pushed = await assignmentsDb.pushToBackOfQueue(
|
|
questionId: questionId,
|
|
firebaseUid: assignedUserId,
|
|
now: now,
|
|
);
|
|
|
|
if (!pushed) {
|
|
return _deferQuestionWithoutAssignment(
|
|
questionId: questionId,
|
|
assignedUserId: assignedUserId,
|
|
modifiedAt: now,
|
|
);
|
|
}
|
|
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
UPDATE questions q
|
|
SET modified_at = @modified_at
|
|
WHERE q.id = @id::uuid
|
|
AND q.assigned_user_id = @uid
|
|
AND q.user_response IS NULL
|
|
RETURNING q.id, q.assigned_user_id, q.question_text, q.user_response,
|
|
q.correct_answer, q.created_at, q.modified_at,
|
|
q.source_tag, q.pipeline_key, q.pipeline_step, q.metadata
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
'modified_at': now,
|
|
},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
return _rowFromResult(result.first);
|
|
}
|
|
|
|
/// Legacy defer for questions without a pending assignment row.
|
|
Future<Map<String, dynamic>?> _deferQuestionWithoutAssignment({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
required DateTime modifiedAt,
|
|
}) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
UPDATE questions q
|
|
SET created_at = sub.max_ts + INTERVAL '1 millisecond',
|
|
modified_at = @modified_at
|
|
FROM (
|
|
SELECT COALESCE(MAX(q.created_at), @modified_at) AS max_ts
|
|
FROM questions q
|
|
WHERE q.assigned_user_id = @uid
|
|
AND q.user_response IS NULL
|
|
AND q.id <> @id::uuid
|
|
) sub
|
|
WHERE q.id = @id::uuid
|
|
AND q.assigned_user_id = @uid
|
|
AND q.user_response IS NULL
|
|
RETURNING q.id, q.assigned_user_id, q.question_text, q.user_response,
|
|
q.correct_answer, q.created_at, q.modified_at,
|
|
q.source_tag, q.pipeline_key, q.pipeline_step, q.metadata
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
'modified_at': modifiedAt,
|
|
},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
return _rowFromResult(result.first);
|
|
}
|
|
|
|
/// Count of unanswered questions assigned to [assignedUserId].
|
|
/// Unanswered [spelling_word_quiz] row for [assignedUserId], if any.
|
|
Future<bool> hasUnansweredSpellingWordQuiz(String assignedUserId) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT 1
|
|
FROM questions
|
|
WHERE assigned_user_id = @uid
|
|
AND user_response IS NULL
|
|
AND pipeline_step = 'spelling_word_quiz'
|
|
AND (
|
|
source_tag LIKE 'spelling:%'
|
|
OR pipeline_key = 'spelling'
|
|
)
|
|
LIMIT 1
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
return result.isNotEmpty;
|
|
}
|
|
|
|
/// Counts unanswered rows whose [resolveSourceId] is in [allowedSourceIds].
|
|
Future<int> countUnansweredForAllowedSources(
|
|
String assignedUserId,
|
|
Set<String> allowedSourceIds,
|
|
) async {
|
|
if (allowedSourceIds.isEmpty) {
|
|
return 0;
|
|
}
|
|
final List<Map<String, dynamic>> rows =
|
|
await listUnansweredQuestions(assignedUserId);
|
|
return filterByAllowedSources(rows, allowedSourceIds).length;
|
|
}
|
|
|
|
Future<int> countUnansweredQuestions(String assignedUserId) async {
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
SELECT COUNT(*)::int AS count
|
|
FROM questions
|
|
WHERE assigned_user_id = @uid AND user_response IS NULL
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': assignedUserId},
|
|
);
|
|
return (result.first[0]! as num).toInt();
|
|
}
|
|
|
|
/// Cumulative guess score for [firebaseUid] (Firebase auth UID), persisted in
|
|
/// `user_trading_state.context.guess_score` and repaired from answer history.
|
|
Future<Map<String, dynamic>> getGuessScoreSummary(String firebaseUid) async {
|
|
await ensureUserExists(firebaseUid);
|
|
return GuessScoreStore.loadSummary(_connection, firebaseUid);
|
|
}
|
|
|
|
/// Resets guess score to a blank slate and clears all guess questions/links.
|
|
Future<Map<String, dynamic>> resetGuessScoreSummary(
|
|
String firebaseUid, {
|
|
DateTime? now,
|
|
}) async {
|
|
final DateTime tick = (now ?? DateTime.now()).toUtc();
|
|
final DateTime earliest = ProspectiveGuessSelection.earliestPlayableSlotStart(
|
|
tick,
|
|
MarketHistoryConfig.windowDays,
|
|
);
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
DELETE FROM market_history_prospective_answers
|
|
WHERE assigned_user_id = @uid
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{'uid': firebaseUid},
|
|
);
|
|
await ProspectiveGuessAssignmentsDb(_connection).deleteAllForUser(
|
|
firebaseUid,
|
|
);
|
|
await deleteAllProspectiveGuessQuestionsForUser(firebaseUid);
|
|
await UserTradingStateDb(_connection).resetGuessScore(
|
|
firebaseUid,
|
|
slotStart: earliest,
|
|
);
|
|
return getGuessScoreSummary(firebaseUid);
|
|
}
|
|
|
|
/// Slot-progressive prospective question for [firebaseUid], or null when caught up.
|
|
Future<Map<String, dynamic>?> pickProspectiveQuestionForUser(
|
|
String firebaseUid, {
|
|
DateTime? now,
|
|
}) async {
|
|
return ProspectiveGuessSelection(connection: _connection).pickForUser(
|
|
firebaseUid,
|
|
now: now,
|
|
);
|
|
}
|
|
|
|
Future<Map<String, dynamic>> createQuestion({
|
|
required String assignedUserId,
|
|
required String questionText,
|
|
required num correctAnswer,
|
|
String? sourceTag,
|
|
String? pipelineKey,
|
|
String? pipelineStep,
|
|
Map<String, dynamic>? metadata,
|
|
}) async {
|
|
await ensureUserExists(assignedUserId);
|
|
final String id = _uuid.v4();
|
|
final DateTime now = DateTime.now().toUtc();
|
|
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
INSERT INTO questions (
|
|
id, assigned_user_id, question_text, user_response, correct_answer,
|
|
created_at, modified_at, source_tag, pipeline_key, pipeline_step,
|
|
metadata
|
|
) VALUES (
|
|
@id::uuid, @assigned_user_id, @question_text, NULL, @correct_answer,
|
|
@created_at, @modified_at, @source_tag, @pipeline_key, @pipeline_step,
|
|
@metadata::jsonb
|
|
)
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': id,
|
|
'assigned_user_id': assignedUserId,
|
|
'question_text': questionText,
|
|
'correct_answer': correctAnswer,
|
|
'created_at': now,
|
|
'modified_at': now,
|
|
'source_tag': sourceTag,
|
|
'pipeline_key': pipelineKey,
|
|
'pipeline_step': pipelineStep,
|
|
'metadata': jsonEncode(metadata ?? <String, dynamic>{}),
|
|
},
|
|
);
|
|
|
|
return _rowToJson(
|
|
id: id,
|
|
assignedUserId: assignedUserId,
|
|
questionText: questionText,
|
|
userResponse: null,
|
|
correctAnswer: correctAnswer,
|
|
createdAt: now,
|
|
modifiedAt: now,
|
|
sourceTag: sourceTag,
|
|
pipelineKey: pipelineKey,
|
|
pipelineStep: pipelineStep,
|
|
metadata: metadata ?? <String, dynamic>{},
|
|
);
|
|
}
|
|
|
|
/// Stable client source id derived from pipeline metadata.
|
|
static String resolveSourceId(Map<String, dynamic> question) {
|
|
final String? sourceTag = question['sourceTag'] as String?;
|
|
if (sourceTag != null && sourceTag.startsWith('spelling:')) {
|
|
return 'spelling';
|
|
}
|
|
if (sourceTag != null && sourceTag.startsWith('market_history:')) {
|
|
return 'market_history';
|
|
}
|
|
final String? pipelineKey = question['pipelineKey'] as String?;
|
|
if (pipelineKey == 'spelling') {
|
|
return 'spelling';
|
|
}
|
|
return 'market_history';
|
|
}
|
|
|
|
/// UI presentation key for [resolveSourceId].
|
|
static String resolvePresentation(Map<String, dynamic> question) {
|
|
final String? step = question['pipelineStep'] as String?;
|
|
final String? sourceTag = question['sourceTag'] as String?;
|
|
if (step == 'spelling_follow_up' || sourceTag == 'spelling:follow_up') {
|
|
return 'market_glyph_slider';
|
|
}
|
|
if (resolveSourceId(question) == 'spelling') {
|
|
return 'spelling_word';
|
|
}
|
|
return 'market_glyph_slider';
|
|
}
|
|
|
|
/// Payload sent to the Flutter client over SignalR (excludes correct answer).
|
|
Map<String, dynamic> toClientPayload(
|
|
Map<String, dynamic> question, {
|
|
required int unansweredCount,
|
|
}) {
|
|
final Map<String, dynamic> metadata = Map<String, dynamic>.from(
|
|
question['metadata'] as Map<String, dynamic>? ?? <String, dynamic>{},
|
|
);
|
|
final String? spokenWord = metadata['displayed_word'] as String?;
|
|
final bool isSpelling = resolveSourceId(question) == 'spelling';
|
|
final bool needsPrepare = isSpelling &&
|
|
(spokenWord == null || spokenWord.isEmpty) &&
|
|
metadata['spelling_pending'] == true;
|
|
final bool isPreparedSpelling =
|
|
isSpelling &&
|
|
spokenWord != null &&
|
|
spokenWord.isNotEmpty &&
|
|
!needsPrepare;
|
|
|
|
return <String, dynamic>{
|
|
'id': question['id'],
|
|
'assignedUserId': question['assignedUserId'],
|
|
'text': question['text'],
|
|
'sentAt': question['createdAt'],
|
|
'unansweredCount': unansweredCount,
|
|
'sourceId': resolveSourceId(question),
|
|
'presentation': resolvePresentation(question),
|
|
if (needsPrepare) 'needsPrepare': true,
|
|
if (isPreparedSpelling) ...<String, dynamic>{
|
|
'spokenWord': spokenWord,
|
|
'audioTitle': question['id'],
|
|
if (metadata['canonical_word'] is String)
|
|
'canonicalWord': metadata['canonical_word'],
|
|
},
|
|
};
|
|
}
|
|
|
|
/// Fills in a reserved spelling quiz after word selection at tile load.
|
|
Future<Map<String, dynamic>?> updateSpellingQuizQuestion({
|
|
required String questionId,
|
|
required String assignedUserId,
|
|
required String questionText,
|
|
required num correctAnswer,
|
|
required Map<String, dynamic> metadata,
|
|
}) async {
|
|
final DateTime now = DateTime.now().toUtc();
|
|
final Result result = await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
UPDATE questions
|
|
SET question_text = @text,
|
|
correct_answer = @answer,
|
|
metadata = @metadata::jsonb,
|
|
modified_at = @now
|
|
WHERE id = @id::uuid
|
|
AND assigned_user_id = @uid
|
|
AND user_response IS NULL
|
|
AND (
|
|
pipeline_step = 'spelling_word_quiz'
|
|
OR source_tag = 'spelling:word_quiz'
|
|
)
|
|
RETURNING id, assigned_user_id, question_text, user_response, correct_answer,
|
|
created_at, modified_at, source_tag, pipeline_key, pipeline_step,
|
|
metadata, user_response_text
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'id': questionId,
|
|
'uid': assignedUserId,
|
|
'text': questionText,
|
|
'answer': correctAnswer,
|
|
'metadata': jsonEncode(metadata),
|
|
'now': now,
|
|
},
|
|
);
|
|
if (result.isEmpty) {
|
|
return null;
|
|
}
|
|
return _rowFromResult(result.first);
|
|
}
|
|
|
|
Map<String, dynamic> _rowFromResult(ResultRow row) {
|
|
final Object idValue = row[0]!;
|
|
final String id = idValue is String ? idValue : idValue.toString();
|
|
final DateTime createdAt = row[5]! as DateTime;
|
|
final DateTime modifiedAt = row[6]! as DateTime;
|
|
return _rowToJson(
|
|
id: id,
|
|
assignedUserId: row[1]! as String,
|
|
questionText: row[2]! as String,
|
|
userResponse: _readOptionalNumeric(row[3]),
|
|
correctAnswer: _readNumeric(row[4]),
|
|
createdAt: createdAt,
|
|
modifiedAt: modifiedAt,
|
|
sourceTag: row.length > 7 ? row[7] as String? : null,
|
|
pipelineKey: row.length > 8 ? row[8] as String? : null,
|
|
pipelineStep: row.length > 9 ? row[9] as String? : null,
|
|
metadata: _readJsonMap(row.length > 10 ? row[10] : null),
|
|
userResponseText: row.length > 11 ? row[11] as String? : null,
|
|
);
|
|
}
|
|
|
|
Map<String, dynamic> _readJsonMap(Object? value) {
|
|
if (value is Map<String, dynamic>) {
|
|
return value;
|
|
}
|
|
if (value is Map) {
|
|
return Map<String, dynamic>.from(value);
|
|
}
|
|
if (value == null) {
|
|
return <String, dynamic>{};
|
|
}
|
|
return jsonDecode(value.toString()) as Map<String, dynamic>;
|
|
}
|
|
|
|
/// Postgres NUMERIC columns may decode as [String] or [num].
|
|
static num _readNumeric(Object? value) {
|
|
if (value == null) {
|
|
return 0;
|
|
}
|
|
if (value is num) {
|
|
return value;
|
|
}
|
|
if (value is String) {
|
|
return num.parse(value);
|
|
}
|
|
return num.parse(value.toString());
|
|
}
|
|
|
|
static num? _readOptionalNumeric(Object? value) {
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
return _readNumeric(value);
|
|
}
|
|
|
|
Future<void> _gradeProspectiveAnswerIfNeeded(
|
|
Map<String, dynamic> answeredQuestion,
|
|
) async {
|
|
final Map<String, dynamic> metadata = Map<String, dynamic>.from(
|
|
answeredQuestion['metadata'] as Map<String, dynamic>? ??
|
|
<String, dynamic>{},
|
|
);
|
|
final bool isProspective = metadata['prospective_question_id'] != null ||
|
|
answeredQuestion['sourceTag'] == 'market_history:prospective';
|
|
if (!isProspective) {
|
|
return;
|
|
}
|
|
|
|
final num? userResponse =
|
|
_readOptionalNumeric(answeredQuestion['userResponse']);
|
|
if (userResponse == null) {
|
|
return;
|
|
}
|
|
|
|
final ProspectiveAnswerGrade grade = gradeProspectiveAnswer(
|
|
userResponse: userResponse,
|
|
correctAnswer: _readNumeric(answeredQuestion['correctAnswer']),
|
|
);
|
|
final String symbol = metadata['symbol'] as String? ?? '';
|
|
final String? modifiedAtWire = answeredQuestion['modifiedAt'] as String?;
|
|
final DateTime at = modifiedAtWire == null
|
|
? DateTime.now().toUtc()
|
|
: DateTime.parse(modifiedAtWire).toUtc();
|
|
|
|
await recordProspectiveGuessScore(
|
|
tradingStateDb: UserTradingStateDb(_connection),
|
|
firebaseUid: answeredQuestion['assignedUserId']! as String,
|
|
grade: grade,
|
|
symbol: symbol,
|
|
at: at,
|
|
);
|
|
}
|
|
|
|
Future<void> _recordProspectiveAnswer(Map<String, dynamic> answeredQuestion) async {
|
|
final Map<String, dynamic> metadata = Map<String, dynamic>.from(
|
|
answeredQuestion['metadata'] as Map<String, dynamic>? ??
|
|
<String, dynamic>{},
|
|
);
|
|
final String? prospectiveQuestionId =
|
|
metadata['prospective_question_id'] as String?;
|
|
if (prospectiveQuestionId == null || prospectiveQuestionId.isEmpty) {
|
|
return;
|
|
}
|
|
final num? userSliderValue =
|
|
_readOptionalNumeric(answeredQuestion['userResponse']);
|
|
if (userSliderValue == null) {
|
|
return;
|
|
}
|
|
final String questionId = answeredQuestion['id']! as String;
|
|
final String assignedUserId = answeredQuestion['assignedUserId']! as String;
|
|
final String? modifiedAtWire = answeredQuestion['modifiedAt'] as String?;
|
|
final DateTime answeredAt = modifiedAtWire == null
|
|
? DateTime.now().toUtc()
|
|
: DateTime.parse(modifiedAtWire).toUtc();
|
|
|
|
await _connection.execute(
|
|
Sql.named(
|
|
'''
|
|
INSERT INTO market_history_prospective_answers (
|
|
question_id, assigned_user_id, prospective_question_id,
|
|
symbol, older_slot_start, newer_slot_start,
|
|
expected_percent_increase_price, user_slider_value, answered_at
|
|
)
|
|
SELECT
|
|
@question_id::uuid, @assigned_user_id, p.id,
|
|
p.symbol, p.older_slot_start, p.newer_slot_start,
|
|
p.price_delta_pct, @user_slider_value, @answered_at
|
|
FROM market_history_prospective_questions p
|
|
WHERE p.id = @prospective_question_id::uuid
|
|
ON CONFLICT (question_id) DO UPDATE
|
|
SET
|
|
prospective_question_id = EXCLUDED.prospective_question_id,
|
|
symbol = EXCLUDED.symbol,
|
|
older_slot_start = EXCLUDED.older_slot_start,
|
|
newer_slot_start = EXCLUDED.newer_slot_start,
|
|
expected_percent_increase_price = EXCLUDED.expected_percent_increase_price,
|
|
user_slider_value = EXCLUDED.user_slider_value,
|
|
answered_at = EXCLUDED.answered_at
|
|
''',
|
|
),
|
|
parameters: <String, dynamic>{
|
|
'question_id': questionId,
|
|
'assigned_user_id': assignedUserId,
|
|
'prospective_question_id': prospectiveQuestionId,
|
|
'user_slider_value': userSliderValue,
|
|
'answered_at': answeredAt,
|
|
},
|
|
);
|
|
}
|
|
|
|
Map<String, dynamic> _rowToJson({
|
|
required String id,
|
|
required String assignedUserId,
|
|
required String questionText,
|
|
required Object? userResponse,
|
|
required num correctAnswer,
|
|
required DateTime createdAt,
|
|
required DateTime modifiedAt,
|
|
String? sourceTag,
|
|
String? pipelineKey,
|
|
String? pipelineStep,
|
|
Map<String, dynamic>? metadata,
|
|
String? userResponseText,
|
|
}) {
|
|
return <String, dynamic>{
|
|
'id': id,
|
|
'assignedUserId': assignedUserId,
|
|
'text': questionText,
|
|
'userResponse': userResponse,
|
|
if (userResponseText != null) 'userResponseText': userResponseText,
|
|
'correctAnswer': correctAnswer,
|
|
'createdAt': createdAt.toIso8601String(),
|
|
'modifiedAt': modifiedAt.toIso8601String(),
|
|
if (sourceTag != null) 'sourceTag': sourceTag,
|
|
if (pipelineKey != null) 'pipelineKey': pipelineKey,
|
|
if (pipelineStep != null) 'pipelineStep': pipelineStep,
|
|
if (metadata != null && metadata.isNotEmpty) 'metadata': metadata,
|
|
};
|
|
}
|
|
}
|