Files
flutterApp/lib/features/v2/waring_center/presentation/bloc/alarm_cubit.dart
2026-08-07 08:49:29 +08:00

260 lines
7.0 KiB
Dart

import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:get_it/get_it.dart';
import 'package:maibu_satabot_v2/features/v2/site/presentation/cubit/site_cubit.dart';
import 'package:maibu_satabot_v2/features/v2/waring_center/domain/entities/alarm_count_entity.dart';
import 'package:maibu_satabot_v2/features/v2/waring_center/domain/entities/alarm_entity.dart';
import 'package:maibu_satabot_v2/features/v2/waring_center/domain/usecases/get_alarm_list_usecase.dart';
import 'package:maibu_satabot_v2/features/v2/waring_center/presentation/bloc/alarm_state.dart';
import 'package:maibu_satabot_v2/features/v2/waring_center/presentation/constants/alarm_constants.dart';
const int _pageSize = 50;
const int _countPageSize = 500;
class AlarmCubit extends Cubit<AlarmState> {
AlarmCubit({
required GetAlarmListUseCase getAlarmListUseCase,
}) : _getAlarmListUseCase = getAlarmListUseCase,
super(AlarmInitial());
final GetAlarmListUseCase _getAlarmListUseCase;
int _loadRequestId = 0;
int? get _siteId {
try {
return GetIt.I<SiteCubit>().state.selectedSite?.id;
} catch (_) {
return null;
}
}
Future<void> loadAlarms({AlarmFilterTab? filter}) async {
final isInitialLoad = state is AlarmInitial;
if (isInitialLoad) {
emit(AlarmLoading());
}
final siteId = _siteId;
final requestId = ++_loadRequestId;
try {
final alarmsResult = await _getAlarmListUseCase(
siteId: siteId,
page: 1,
pageSize: _pageSize,
);
final allAlarms = alarmsResult.fold(
(failure) => <AlarmEntity>[],
(alarms) => alarms,
);
final selectedFilter = filter ?? AlarmFilterTab.all;
final filteredAlarms = _filterAlarms(allAlarms, selectedFilter);
emit(
AlarmLoaded(
allAlarms: allAlarms,
alarms: filteredAlarms,
count: const AlarmCountEntity(
unprocessed: 0,
processing: 0,
confirmed: 0,
todayNew: 0,
),
selectedFilter: selectedFilter,
currentPage: 1,
hasMore: allAlarms.length >= _pageSize,
isCountLoading: true,
),
);
_loadAndCalculateCounts(siteId, requestId);
} catch (e) {
emit(AlarmError('加载告警数据失败: $e'));
}
}
Future<void> _loadAndCalculateCounts(
int? siteId,
int requestId,
) async {
try {
final result = await _getAlarmListUseCase(
siteId: siteId,
page: 1,
pageSize: _countPageSize,
);
if (requestId != _loadRequestId) return;
result.fold(
(failure) {
if (requestId != _loadRequestId) return;
final currentState = state;
if (currentState is AlarmLoaded) {
emit(currentState.copyWith(
isCountLoading: false,
count: const AlarmCountEntity(
unprocessed: 0,
processing: 0,
confirmed: 0,
todayNew: 0,
),
));
}
},
(alarms) {
if (requestId != _loadRequestId) return;
final count = _calculateCounts(alarms);
final currentState = state;
if (currentState is AlarmLoaded) {
emit(currentState.copyWith(
isCountLoading: false,
count: count,
));
}
},
);
} catch (e) {
if (requestId != _loadRequestId) return;
final currentState = state;
if (currentState is AlarmLoaded) {
emit(currentState.copyWith(
isCountLoading: false,
count: const AlarmCountEntity(
unprocessed: 0,
processing: 0,
confirmed: 0,
todayNew: 0,
),
));
}
}
}
AlarmCountEntity _calculateCounts(List<AlarmEntity> alarms) {
final now = DateTime.now();
final today = DateTime(now.year, now.month, now.day);
int unprocessed = 0;
int confirmed = 0;
int todayNew = 0;
for (final alarm in alarms) {
if (alarm.status == AlarmStatus.pending) {
unprocessed++;
}
if (alarm.status == AlarmStatus.closed) {
confirmed++;
}
try {
final alarmTime = DateTime.parse(alarm.time);
final alarmDate = DateTime(
alarmTime.year,
alarmTime.month,
alarmTime.day,
);
if (alarmDate == today) {
todayNew++;
}
} catch (_) {}
}
return AlarmCountEntity(
unprocessed: unprocessed,
processing: 0,
confirmed: confirmed,
todayNew: todayNew,
);
}
Future<void> loadMore() async {
final currentState = state;
if (currentState is! AlarmLoaded) return;
if (currentState.isLoadingMore || !currentState.hasMore) return;
emit(currentState.copyWith(isLoadingMore: true));
final siteId = _siteId;
final nextPage = currentState.currentPage + 1;
try {
final alarmsResult = await _getAlarmListUseCase(
siteId: siteId,
page: nextPage,
pageSize: _pageSize,
);
final newAlarms = alarmsResult.fold(
(failure) => <AlarmEntity>[],
(alarms) => alarms,
);
final updatedAllAlarms = [
...currentState.allAlarms,
...newAlarms,
];
final filteredAlarms = _filterAlarms(
updatedAllAlarms,
currentState.selectedFilter,
);
emit(
AlarmLoaded(
allAlarms: updatedAllAlarms,
alarms: filteredAlarms,
count: currentState.count,
selectedFilter: currentState.selectedFilter,
currentPage: nextPage,
hasMore: newAlarms.length >= _pageSize,
isLoadingMore: false,
isCountLoading: currentState.isCountLoading,
),
);
} catch (e) {
emit(currentState.copyWith(isLoadingMore: false));
}
}
void changeFilter(AlarmFilterTab filter) {
final currentState = state;
if (currentState is AlarmLoaded) {
final filteredAlarms = _filterAlarms(currentState.allAlarms, filter);
emit(
currentState.copyWith(alarms: filteredAlarms, selectedFilter: filter),
);
}
}
Future<void> refresh() async {
final currentState = state;
if (currentState is AlarmLoaded) {
await loadAlarms(filter: currentState.selectedFilter);
} else {
await loadAlarms();
}
}
List<AlarmEntity> _filterAlarms(
List<AlarmEntity> alarms,
AlarmFilterTab filter,
) {
switch (filter) {
case AlarmFilterTab.unprocessed:
return alarms
.where((alarm) => alarm.status == AlarmStatus.pending)
.toList();
case AlarmFilterTab.confirmed:
return alarms
.where((alarm) => alarm.status == AlarmStatus.processing)
.toList();
case AlarmFilterTab.recovered:
return alarms
.where((alarm) => alarm.status == AlarmStatus.closed)
.toList();
case AlarmFilterTab.all:
return alarms;
}
}
}