468 lines
19 KiB
Dart
468 lines
19 KiB
Dart
import 'package:cloud_firestore/cloud_firestore.dart' show Timestamp;
|
|
|
|
import '../../core/data/backend.dart';
|
|
import '../../core/data/invite_code.dart';
|
|
import '../../core/data/server_clock.dart';
|
|
import '../../core/ui/planet_25d.dart' show planetColors, planetColorsFrom, setPlanetColorMaster;
|
|
import 'package:flutter/painting.dart' show Color;
|
|
import 'home_data.dart';
|
|
import '../inside/inside_repository_firestore.dart' show insideQuestionFrom;
|
|
import '../quest/quest_data.dart' show QuestType;
|
|
import '../quest/quest_repository_firestore.dart' show questToday;
|
|
import '../../core/i18n/app_locale.dart';
|
|
|
|
/// 홈의 실 서버 구현 — 화면 대조 원장 F1.
|
|
///
|
|
/// [SampleHomeRepository] 와 같은 인터페이스라 화면은 어느 쪽이 붙었는지 모른다.
|
|
/// 값의 출처만 표본에서 Firestore 로 바뀐다.
|
|
///
|
|
/// 성장 조건은 팬덤 공동 상태와 Stage 마스터에서 읽는다.
|
|
/// 개인 멤버 기여량/개인 행성 Stage는 공동 성장으로 대체하지 않는다.
|
|
class FirestoreHomeRepository implements HomeRepository {
|
|
FirestoreHomeRepository(this._backend);
|
|
|
|
final Backend _backend;
|
|
|
|
@override
|
|
Stream<PlanetGrowth> watchGrowth(String fandomId) {
|
|
if (fandomId.isEmpty) return const Stream.empty();
|
|
return _backend.db
|
|
.doc('fandoms/$fandomId')
|
|
.snapshots(includeMetadataChanges: true)
|
|
.where((s) => !s.metadata.isFromCache && !s.metadata.hasPendingWrites)
|
|
.asyncMap((s) => _growth(s.data() ?? const {}, fandomId));
|
|
}
|
|
|
|
@override
|
|
Stream<int> watchPopBalance() => _backend.db
|
|
.doc('users/${_backend.requireUid}/wallet/main')
|
|
.snapshots()
|
|
.map(
|
|
(s) => (s.data() ?? const <String, dynamic>{}).intOr('activityBalance'),
|
|
);
|
|
|
|
@override
|
|
Future<({String fandomId, bool primaryChanged})> createNebula(
|
|
String name,
|
|
) async {
|
|
final data = await _backend.call('fnNebulaCreate', {'name': name});
|
|
final fandomId = data['fandomId'];
|
|
// ID 없이 성공으로 돌아오면 화면이 빈 ID 로 성운 상세를 연다 — 실패로 다룬다.
|
|
if (fandomId is! String || fandomId.isEmpty) {
|
|
throw BackendException('E-SYS-01', appL10n.nebulaCreateFailed);
|
|
}
|
|
return (
|
|
fandomId: fandomId,
|
|
primaryChanged: data['primaryChanged'] != false,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<void> createPlanet({
|
|
required String fandomId,
|
|
required String planetType,
|
|
required String colorKey,
|
|
}) => _backend.call('fnPlanetCreate', {
|
|
'fandomId': fandomId,
|
|
'planetType': planetType,
|
|
'colorKey': colorKey,
|
|
});
|
|
|
|
@override
|
|
Future<List<(String, Color)>> planetColorOptions() async {
|
|
try {
|
|
final master = planetColorsFrom(
|
|
(await _backend.db.doc('config/planetColors').get()).data(),
|
|
);
|
|
setPlanetColorMaster(master.all);
|
|
return master.visible;
|
|
} catch (_) {
|
|
return planetColors;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<NebulaTargets> nebulaTargets() async {
|
|
try {
|
|
return nebulaTargetsFrom(
|
|
(await _backend.db.doc('config/policy').get()).data(),
|
|
);
|
|
} catch (_) {
|
|
return defaultNebulaTargets;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<HomeSnapshot> load() async {
|
|
final uid = _backend.requireUid;
|
|
// 공유 링크 `?ref=` 용 — 기다리지 않는다.
|
|
InviteCode.ensure(_backend);
|
|
// 컬러 마스터 — HOME · GALAXY 행성이 발주사가 더한 색도 그리도록 먼저 읽어 둔다. 기다리지 않는다.
|
|
planetColorOptions();
|
|
final db = _backend.db;
|
|
|
|
final userSnap = await db.doc('users/$uid').get();
|
|
final user = userSnap.data() ?? const <String, dynamic>{};
|
|
final fandomId = user.strOr('fandomId');
|
|
|
|
// 홈 한 화면에 필요한 것을 병렬로 띄운다. 순차로 기다리면 왕복이 그대로 쌓인다.
|
|
final walletF = db.doc('users/$uid/wallet/main').get();
|
|
final fandomF = fandomId.isEmpty ? null : db.doc('fandoms/$fandomId').get();
|
|
// TODAY'S QUEST — 설명 프레임 `2097:16397` 「관리자 퀘스트 최신순 최대 3개」. 사용자 생성
|
|
// 퀘스트(`authorUid` 있음)는 HOME 에 띄우지 않는다. 정렬 · 거르기는 아래에서 한다.
|
|
// ponytail: 활성 30건 안에서만 고른다. (active, createdAt) 색인을 배포하면 질의로 옮긴다.
|
|
final questsF = db
|
|
.collection('quests')
|
|
.where('active', isEqualTo: true)
|
|
.limit(30)
|
|
.get();
|
|
// 긴급 돌발 타임어택(FR-QST-06) — 내 팬덤의 **열린 창**만. 위 목록과 따로 읽어 맨 앞에
|
|
// 둔다. 위 질의는 정렬이 없어 5 건 안에 든다는 보장이 없다. 색인 `firestore.indexes.json`.
|
|
// 질의는 단말 시계 기준 1시간 여유로 넓게 받고, 마감 판정은 아래에서 서버 시각으로 한다.
|
|
// ponytail: 단말 시계가 1시간 넘게 빠르면 열린 창을 놓친다. 그때는 여유를 늘린다.
|
|
final timeAttacksF = fandomId.isEmpty
|
|
? null
|
|
: db
|
|
.collection('quests')
|
|
.where('type', isEqualTo: 'timeattack')
|
|
.where('fandomId', isEqualTo: fandomId)
|
|
.where(
|
|
'activeTo',
|
|
isGreaterThan: Timestamp.fromDate(
|
|
DateTime.now().subtract(const Duration(hours: 1)),
|
|
),
|
|
)
|
|
.limit(10)
|
|
.get();
|
|
final progressF = db.collection('users/$uid/questProgress').get();
|
|
// 출석 보상은 서버가 `config/policy.attendPop` 으로 지급한다. 같은 곳을 읽는다.
|
|
final policyF = db.doc('config/policy').get();
|
|
// 브리핑은 **게시된 당일분만** 읽는다 — 정책 원장 B-47 「당일 승인된 콘텐츠만
|
|
// 노출 · 미승인 Draft 노출 0건 · 전일 콘텐츠 자동 재사용 없음」. 세 조건을
|
|
// 질의에 두어 화면이 걸러 낼 것이 남지 않게 한다. 앱에서 거르면 초안이 기기에
|
|
// 한 번 내려온 뒤에 지워지는 것이라 「노출 0건」이 아니다.
|
|
final briefingsF = db
|
|
.collection('briefings')
|
|
.where('fandomId', isEqualTo: fandomId)
|
|
.where('status', isEqualTo: 'published')
|
|
.where('dayKey', isEqualTo: kstDayKey())
|
|
// **섹션별로 rank 를 매기므로 정렬 키가 둘이다.** `rank` 만으로 자르면
|
|
// News 3 건 + SNS 1 건일 때 rank 3 두 개가 경쟁해 News 셋째 줄이 잘린다.
|
|
// 상한 6 은 두 구획 각 3 줄 기준이다(Figma 홈의 3 줄 × 구획 2).
|
|
.orderBy('section')
|
|
.orderBy('rank')
|
|
.limit(6)
|
|
.get();
|
|
// HOT ARCHIVE 캐러셀 — 명세 §2.114-6 「최대 5개」. 차단한 개설자의 캠페인은 건너뛰므로
|
|
// 열 건을 읽어 다섯을 채운다. ponytail: 정렬은 모금액 순 하나(명세의 「달성 임박 > 기여 급증 >
|
|
// 신규」 3단 정렬은 기여 급증 집계가 없어 아직 못 한다).
|
|
final campaignF = db
|
|
.collection('campaigns')
|
|
.where('status', isEqualTo: 'funding')
|
|
.orderBy('raisedPop', descending: true)
|
|
.limit(10)
|
|
.get();
|
|
// 팬덤행성 인큐베이터 — 명세 §2.114-4 「기여율 높은 순 최대 6개」. 성운(Stage0)만.
|
|
// ponytail: 성운 30건 안에서 고른다. (stage, growthPop) 색인을 배포하면 질의로 옮긴다.
|
|
final nebulasF = db
|
|
.collection('fandoms')
|
|
.where('stage', isEqualTo: 0)
|
|
.limit(30)
|
|
.get();
|
|
final blocksF = db.collection('users/$uid/blocks').get();
|
|
// Hero Gift Catalog(원장 B-85) — 판매 중인 것만. 소속 행성이 없는 사용자는 시트가
|
|
// 결제 창을 열기 전에 막는다(`fn-iap-verify` 도 거부한다).
|
|
final itemsF = db
|
|
.collection('heroGiftProducts')
|
|
.where('active', isEqualTo: true)
|
|
.get();
|
|
// 인기 K-INSIDE — 기능명세서 v1.4 §2.114-7 「최대 3개 소팅(미해결 + 고액 포인트 순)」.
|
|
// 미해결(`open`) 먼저, 그 안에서 현상금 큰 순. 정렬은 아래 [popularInsides].
|
|
// ponytail: 현상금 상위 20건 안에서만 고른다. (status, bountyPop) 색인을 배포하면 질의로 옮긴다.
|
|
final insidesF = db
|
|
.collection('questions')
|
|
.orderBy('bountyPop', descending: true)
|
|
.limit(20)
|
|
.get();
|
|
|
|
final wallet = (await walletF).data() ?? const <String, dynamic>{};
|
|
final fandom = fandomF == null
|
|
? const <String, dynamic>{}
|
|
: ((await fandomF).data() ?? const <String, dynamic>{});
|
|
final timeAttacks = [
|
|
for (final doc in (await timeAttacksF)?.docs ?? const [])
|
|
if (doc.data()['active'] != false) doc,
|
|
];
|
|
if (timeAttacks.isNotEmpty) await ServerClock.ensure(_backend);
|
|
final serverNow = ServerClock.now();
|
|
final quests = [
|
|
...timeAttacks.where((d) {
|
|
final to = d.data()['activeTo'];
|
|
return to is Timestamp && to.toDate().isAfter(serverNow);
|
|
}),
|
|
// 타임어택은 위에서 창이 열린 것만 받았다. 여기서 다시 받으면 마감된 것이 남는다.
|
|
...adminQuestsLatest([
|
|
for (final d in (await questsF).docs)
|
|
if (d.data()['type'] != 'timeattack') d,
|
|
], (d) => d.data()),
|
|
].take(3).toList();
|
|
final progress = (await progressF).docs;
|
|
final briefings = (await briefingsF).docs;
|
|
final blocked = {for (final d in (await blocksF).docs) d.id};
|
|
final campaigns = (await campaignF).docs
|
|
.where((d) => !blocked.contains(d.data()['creatorUid']))
|
|
.toList();
|
|
final insideDocs = {
|
|
for (final doc in (await insidesF).docs) doc.data(): doc.id,
|
|
};
|
|
final insides = [
|
|
for (final data in popularInsides(insideDocs.keys.toList()))
|
|
(insideDocs[data]!, data),
|
|
];
|
|
|
|
final progressById = {for (final doc in progress) doc.id: doc.data()};
|
|
final policy = (await policyF).data() ?? const <String, dynamic>{};
|
|
|
|
return HomeSnapshot(
|
|
popBalance: wallet.intOr('activityBalance'),
|
|
fandomId: fandomId,
|
|
liveTicker: fandom.strOr('liveTicker').isEmpty
|
|
? null
|
|
: fandom.strOr('liveTicker'),
|
|
growth: await _growth(fandom, fandomId),
|
|
quests: [
|
|
for (final doc in quests)
|
|
_quest(doc.id, doc.data(), progressById[doc.id], policy),
|
|
],
|
|
briefings: [for (final doc in briefings) ?_briefing(doc.data())],
|
|
campaigns: [for (final d in campaigns.take(5)) _campaign(d.id, d.data())],
|
|
insides: [
|
|
for (final (id, data) in insides) insideQuestionFrom(id, data, uid),
|
|
],
|
|
nebulas: nebulaPicks([
|
|
for (final d in (await nebulasF).docs) (d.id, d.data()),
|
|
], nebulaTargetsFrom(policy).pop),
|
|
items: [for (final doc in (await itemsF).docs) _item(doc.id, doc.data())],
|
|
);
|
|
}
|
|
|
|
/// 문서 ID 가 스토어 상품 ID 다. 수치는 Admin 저장값 그대로(B-84 · 환율 재계산 없음).
|
|
ItemProduct _item(String productId, Map<String, dynamic> data) => ItemProduct(
|
|
productId: productId,
|
|
name: data.strOr('name', productId),
|
|
description: data.strOr('description'),
|
|
dropPop: data.intOr('dropPop'),
|
|
buyerPop: data.intOr('buyerPop'),
|
|
priceWon: data.intOr('priceWon'),
|
|
// 구매 즉시 Drop 이 열려 보유 재고가 생기지 않는다.
|
|
owned: 0,
|
|
);
|
|
|
|
/// 브리핑 한 줄 — 정책 원장 B-75 5 요소가 전건 있어야 그린다.
|
|
///
|
|
/// **하나라도 비면 그 줄을 버린다.** 서버가 수신 단계에서 이미 거부하지만
|
|
/// (`fn-briefing-ingest`), Admin 수동 편집이나 예전 스키마 문서가 섞일 수 있다.
|
|
/// 여기서 통과시키면 출처가 빈 카드가 화면에 뜨고 그것이 B-75 위반이다.
|
|
/// 섹션이 News·SNS 밖이면 정책이 정한 구획이 아니므로 역시 버린다.
|
|
BriefingItem? _briefing(Map<String, dynamic> data) {
|
|
final section = BriefingSection.of(data.strOr('section'));
|
|
final headline = data.strOr('headline');
|
|
final sourceName = data.strOr('sourceName');
|
|
final sourceUrl = data.strOr('sourceUrl');
|
|
final articleUrl = data.strOr('articleUrl');
|
|
final aiSummary = data.strOr('aiSummary');
|
|
final sourceAt = data['sourceAt'];
|
|
if (section == null ||
|
|
headline.isEmpty ||
|
|
sourceName.isEmpty ||
|
|
sourceUrl.isEmpty ||
|
|
articleUrl.isEmpty ||
|
|
aiSummary.isEmpty ||
|
|
sourceAt == null) {
|
|
return null;
|
|
}
|
|
return BriefingItem(
|
|
rank: data.intOr('rank', 1),
|
|
headline: headline,
|
|
section: section,
|
|
sourceName: sourceName,
|
|
sourceAt: data.dateOr('sourceAt', DateTime.now()),
|
|
sourceUrl: sourceUrl,
|
|
articleUrl: articleUrl,
|
|
aiSummary: aiSummary,
|
|
);
|
|
}
|
|
|
|
Future<PlanetGrowth> _growth(
|
|
Map<String, dynamic> fandom,
|
|
String fandomId,
|
|
) async {
|
|
final stage = switch (fandom['stage']) {
|
|
int n when n >= 0 && n <= 6 => n,
|
|
_ => null,
|
|
};
|
|
// Stage0의 탄생은 별도의 멤버/POP 조건이다. Stage1 마스터의 0으로 승급을 추정하지 않는다.
|
|
final next = stage != null && stage > 0 && stage < 6
|
|
? (await _backend.db.doc('planetStages/${stage + 1}').get()).data()
|
|
: null;
|
|
int? validInt(dynamic value) => value is int && value >= 0 ? value : null;
|
|
num? validNumber(dynamic value) =>
|
|
value is num && value.isFinite && value >= 0 ? value : null;
|
|
// 정식 행성은 서버가 수치표 v1.4 대로 적은 레벨업 POP 진행도(생성 기준점 이후 · ZAP 가중치 반영)와
|
|
// 다음 Stage 진입 누계를 쓴다. 아직 판정 전인 행성만 구 마스터(`planetStages`)로 그린다.
|
|
final leveled = stage != null && stage > 0 && fandom['levelPop'] is num;
|
|
final current = leveled
|
|
? validNumber(fandom['levelPop'])
|
|
: validNumber(fandom['growthPop']);
|
|
final required = leveled
|
|
? validInt(fandom['nextStagePop'])
|
|
: validInt(next?['requiredPop']);
|
|
// 성운(Stage0)의 전환 목표는 서버와 같은 `config/policy` 키로 읽는다.
|
|
final policy = stage == 0
|
|
? (await _backend.db.doc('config/policy').get()).data()
|
|
: null;
|
|
final targets = stage == 0 ? nebulaTargetsFrom(policy) : null;
|
|
final goal = targets?.pop ?? required;
|
|
// Q-PN-02 — 기간이 지난 성운은 운영 설정이 막지 않는 한 조건만 채우면 탄생한다(서버와 같은 판정).
|
|
final deadline = fandom['nebulaDeadline'];
|
|
final goalPassed =
|
|
stage == 0 &&
|
|
deadline is Timestamp &&
|
|
ServerClock.now().isAfter(deadline.toDate()) &&
|
|
policy?['nebulaConversionDeadlineEnforced'] != true;
|
|
return PlanetGrowth(
|
|
stage: stage,
|
|
fandomName: fandom.strOr('name', fandomId),
|
|
// 기존 데이터에 이메일 형태가 남아 있어도 가린다.
|
|
contributorName: fandom.containsKey('lastContributorName')
|
|
? publicName(fandom['lastContributorName'])
|
|
: '',
|
|
contributedPop: fandom.intOr('lastContributedPop'),
|
|
growthPercent: current != null && goal != null && goal > 0
|
|
? ((current / goal) * 100).clamp(0, 100).round()
|
|
: null,
|
|
currentPop: current,
|
|
requiredPop: goal,
|
|
currentSfpi: validNumber(fandom['sfpi']),
|
|
members: validInt(fandom['memberCount']),
|
|
requiredMembers: targets?.members,
|
|
// Q-PN-01 A안 — 탄생은 창립자만.
|
|
isFounder:
|
|
fandom['founderUid'] != null && fandom['founderUid'] == _backend.uid,
|
|
requiredSfpi: leveled
|
|
? validNumber(fandom['nextStageSfpi'])
|
|
: validNumber(next?['requiredSfpi']),
|
|
nebulaGoalPassed: goalPassed,
|
|
);
|
|
}
|
|
|
|
QuestSummary _quest(
|
|
String id,
|
|
Map<String, dynamic> quest,
|
|
Map<String, dynamic>? progress,
|
|
Map<String, dynamic> policy,
|
|
) {
|
|
// 퀘스트 목록 · 상세와 같은 판정(`questToday`) — 오늘(KST) 행만 센다.
|
|
final (:count, :done) = questToday(
|
|
QuestType.parse(quest.strOr('type')),
|
|
quest,
|
|
progress,
|
|
policy,
|
|
);
|
|
final started = count > 0;
|
|
return QuestSummary(
|
|
title: quest.strOr('title'),
|
|
type: QuestType.parse(quest.strOr('type')),
|
|
category: QuestType.parse(quest.strOr('type')).label,
|
|
rewardPop: QuestType.parse(quest.strOr('type')).rewardFrom(quest, policy),
|
|
state: done
|
|
? QuestState.done
|
|
: started
|
|
? QuestState.claimable
|
|
: QuestState.inProgress,
|
|
progressLabel: quest.strOr('progressLabel').isEmpty
|
|
? null
|
|
: quest.strOr('progressLabel'),
|
|
id: id,
|
|
endsAt: quest['type'] == 'timeattack' && quest['activeTo'] is Timestamp
|
|
? (quest['activeTo'] as Timestamp).toDate()
|
|
: null,
|
|
);
|
|
}
|
|
|
|
CampaignHighlight _campaign(String id, Map<String, dynamic> data) {
|
|
// 규칙의 스키마 이름(`targetPop` · `creatorName` · `summary`)을 먼저 읽는다.
|
|
final goal = data.intOr('targetPop', data.intOr('goalPop'));
|
|
final raised = data.intOr('raisedPop');
|
|
return CampaignHighlight(
|
|
id: id,
|
|
authorName: publicName(data['creatorName'] ?? data['authorName']),
|
|
achievedPercent: goal == 0 ? 0 : ((raised / goal) * 100).round(),
|
|
title: data.strOr('title'),
|
|
description: data.strOr('summary', data.strOr('description')),
|
|
supporters: data.intOr('donorCount'),
|
|
comments: data.intOr('commentCount'),
|
|
likes: data.intOr('likeCount'),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// 인기 K-INSIDE 3건 — 미해결(`status == open`) 먼저, 같은 묶음 안에서는 현상금 큰 순.
|
|
/// 입력이 현상금 내림차순이라 미해결 묶음만 앞으로 옮기면 된다.
|
|
List<Map<String, dynamic>> popularInsides(
|
|
List<Map<String, dynamic>> byBounty,
|
|
) => [
|
|
...byBounty.where((q) => q['status'] == 'open'),
|
|
...byBounty.where((q) => q['status'] != 'open'),
|
|
].take(3).toList();
|
|
|
|
/// 오늘 날짜(KST `YYYY-MM-DD`) — 서버 `briefings.dayKey` 와 같은 규약이다.
|
|
///
|
|
/// 단말 시간대로 끊으면 해외 사용자의 「오늘」이 서버의 `dayKey` 와 달라 브리핑이
|
|
/// 안 보인다. 브리핑은 한국 시간 기준 하루다.
|
|
String kstDayKey([DateTime? at]) => (at ?? DateTime.now().toUtc())
|
|
.toUtc()
|
|
.add(const Duration(hours: 9))
|
|
.toIso8601String()
|
|
.substring(0, 10);
|
|
|
|
/// HOME TODAY'S QUEST 의 관리자 퀘스트 — `authorUid` 가 없는 것만, `createdAt` 최신순
|
|
/// (설명 프레임 `2097:16397` 「관리자 퀘스트 - 최신순으로 최대 3개 노출」).
|
|
List<T> adminQuestsLatest<T>(
|
|
Iterable<T> docs,
|
|
Map<String, dynamic> Function(T) data,
|
|
) {
|
|
DateTime at(T d) => switch (data(d)['createdAt']) {
|
|
Timestamp t => t.toDate(),
|
|
DateTime t => t,
|
|
_ => DateTime.fromMillisecondsSinceEpoch(0),
|
|
};
|
|
return [
|
|
for (final d in docs)
|
|
if ((data(d)['authorUid'] ?? '').toString().isEmpty) d,
|
|
]..sort((a, b) => at(b).compareTo(at(a)));
|
|
}
|
|
|
|
/// 인큐베이터 카드 — 기여율(누적 POP ÷ 성운 전환 목표 POP) 높은 순 최대 6개.
|
|
List<NebulaPick> nebulaPicks(
|
|
Iterable<(String, Map<String, dynamic>)> docs,
|
|
int goalPop,
|
|
) {
|
|
final picks = [
|
|
for (final (id, d) in docs)
|
|
NebulaPick(
|
|
id: id,
|
|
name: d.strOr('name', id),
|
|
members: d.intOr('memberCount'),
|
|
percent: goalPop <= 0
|
|
? 0
|
|
: ((d['growthPop'] is num ? d['growthPop'] as num : 0) /
|
|
goalPop *
|
|
100)
|
|
.clamp(0, 100)
|
|
.floor(),
|
|
),
|
|
]..sort((a, b) => b.percent.compareTo(a.percent));
|
|
return picks.take(6).toList();
|
|
}
|