mirror of
https://github.com/SyncrowIOT/web.git
synced 2025-07-10 07:07:19 +00:00
200 lines
6.3 KiB
Dart
200 lines
6.3 KiB
Dart
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:syncrow_web/pages/spaces_management/model/community_model.dart';
|
|
import 'package:syncrow_web/pages/spaces_management/model/product_model.dart';
|
|
import 'package:syncrow_web/pages/spaces_management/model/space_model.dart';
|
|
import 'package:syncrow_web/pages/spaces_management/bloc/space_management_event.dart';
|
|
import 'package:syncrow_web/pages/spaces_management/bloc/space_management_state.dart';
|
|
import 'package:syncrow_web/services/product_api.dart';
|
|
import 'package:syncrow_web/services/space_mana_api.dart';
|
|
|
|
class SpaceManagementBloc extends Bloc<SpaceManagementEvent, SpaceManagementState> {
|
|
final CommunitySpaceManagementApi _api;
|
|
final ProductApi _productApi;
|
|
|
|
List<ProductModel>? _cachedProducts;
|
|
|
|
SpaceManagementBloc(this._api, this._productApi) : super(SpaceManagementInitial()) {
|
|
on<LoadCommunityAndSpacesEvent>(_onLoadCommunityAndSpaces);
|
|
on<UpdateSpacePositionEvent>(_onUpdateSpacePosition);
|
|
on<CreateCommunityEvent>(_onCreateCommunity);
|
|
on<SaveSpacesEvent>(_onSaveSpaces);
|
|
on<FetchProductsEvent>(_onFetchProducts);
|
|
}
|
|
|
|
void _onFetchProducts(
|
|
FetchProductsEvent event,
|
|
Emitter<SpaceManagementState> emit,
|
|
) async {
|
|
if (_cachedProducts != null) {
|
|
// Products are already cached, no need to fetch again
|
|
return;
|
|
}
|
|
|
|
try {
|
|
final products = await _productApi.fetchProducts();
|
|
_cachedProducts = products; // Cache the products locally
|
|
} catch (e) {
|
|
emit(SpaceManagementError('Error fetching products: $e'));
|
|
}
|
|
}
|
|
|
|
void _onLoadCommunityAndSpaces(
|
|
LoadCommunityAndSpacesEvent event,
|
|
Emitter<SpaceManagementState> emit,
|
|
) async {
|
|
emit(SpaceManagementLoading());
|
|
try {
|
|
if (_cachedProducts == null) {
|
|
final products = await _productApi.fetchProducts();
|
|
_cachedProducts = products;
|
|
}
|
|
|
|
// Fetch all communities
|
|
List<CommunityModel> communities = await _api.fetchCommunities();
|
|
|
|
// Use Future.wait to handle async calls within map
|
|
List<CommunityModel> updatedCommunities = await Future.wait(
|
|
communities.map((community) async {
|
|
List<SpaceModel> spaces = await _api.getSpaceHierarchy(community.uuid);
|
|
return CommunityModel(
|
|
uuid: community.uuid,
|
|
createdAt: community.createdAt,
|
|
updatedAt: community.updatedAt,
|
|
name: community.name,
|
|
description: community.description,
|
|
spaces: spaces, // New spaces list
|
|
region: community.region,
|
|
);
|
|
}).toList(),
|
|
);
|
|
|
|
emit(SpaceManagementLoaded(communities: updatedCommunities, products: _cachedProducts ?? []));
|
|
} catch (e) {
|
|
emit(SpaceManagementError('Error loading communities and spaces: $e'));
|
|
}
|
|
}
|
|
|
|
void _onUpdateSpacePosition(
|
|
UpdateSpacePositionEvent event,
|
|
Emitter<SpaceManagementState> emit,
|
|
) {
|
|
// Handle space position update logic
|
|
}
|
|
|
|
void _onCreateCommunity(
|
|
CreateCommunityEvent event,
|
|
Emitter<SpaceManagementState> emit,
|
|
) async {
|
|
final previousState = state;
|
|
emit(SpaceManagementLoading());
|
|
|
|
try {
|
|
CommunityModel? newCommunity = await _api.createCommunity(
|
|
event.name,
|
|
event.description,
|
|
event.regionId,
|
|
);
|
|
|
|
if (newCommunity != null) {
|
|
if (previousState is SpaceManagementLoaded) {
|
|
final updatedCommunities = List<CommunityModel>.from(previousState.communities)
|
|
..add(newCommunity);
|
|
emit(SpaceManagementLoaded(
|
|
communities: updatedCommunities, products: _cachedProducts ?? []));
|
|
}
|
|
} else {
|
|
emit(const SpaceManagementError('Error creating community'));
|
|
}
|
|
} catch (e) {
|
|
emit(SpaceManagementError('Error creating community: $e'));
|
|
}
|
|
}
|
|
|
|
|
|
void _onSaveSpaces(
|
|
SaveSpacesEvent event,
|
|
Emitter<SpaceManagementState> emit,
|
|
) async {
|
|
final previousState = state;
|
|
emit(SpaceManagementLoading());
|
|
|
|
try {
|
|
final updatedSpaces = await saveSpacesHierarchically(event.spaces, event.communityUuid);
|
|
emit(SpaceCreationSuccess(spaces: updatedSpaces));
|
|
add(LoadCommunityAndSpacesEvent());
|
|
} catch (e) {
|
|
emit(SpaceManagementError('Error saving spaces: $e'));
|
|
if (previousState is SpaceManagementLoaded) {
|
|
emit(previousState);
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<List<SpaceModel>> saveSpacesHierarchically(
|
|
List<SpaceModel> spaces, String communityUuid) async {
|
|
final orderedSpaces = flattenHierarchy(spaces);
|
|
|
|
for (var space in orderedSpaces) {
|
|
try {
|
|
if (space.uuid != null && space.uuid!.isNotEmpty) {
|
|
// Call update if the space already has a UUID
|
|
final response = await _api.updateSpace(
|
|
communityId: communityUuid,
|
|
spaceId: space.uuid!,
|
|
name: space.name,
|
|
parentId: space.parent?.uuid,
|
|
isPrivate: space.isPrivate,
|
|
position: space.position,
|
|
icon: space.icon,
|
|
direction: space.incomingConnection?.direction,
|
|
products: space.selectedProducts
|
|
);
|
|
} else {
|
|
// Call create if the space does not have a UUID
|
|
final response = await _api.createSpace(
|
|
communityId: communityUuid,
|
|
name: space.name,
|
|
parentId: space.parent?.uuid,
|
|
isPrivate: space.isPrivate,
|
|
position: space.position,
|
|
icon: space.icon,
|
|
direction: space.incomingConnection?.direction,
|
|
products: space.selectedProducts
|
|
|
|
);
|
|
space.uuid = response?.uuid;
|
|
}
|
|
} catch (e) {
|
|
print('Error creating space ${space.name}: $e');
|
|
rethrow; // Stop further execution on failure
|
|
}
|
|
}
|
|
return spaces;
|
|
}
|
|
|
|
List<SpaceModel> flattenHierarchy(List<SpaceModel> spaces) {
|
|
final result = <SpaceModel>{};
|
|
final topLevelSpaces = spaces.where((space) => space.parent == null);
|
|
|
|
void visit(SpaceModel space) {
|
|
if (!result.contains(space)) {
|
|
result.add(space);
|
|
for (var child in spaces.where((s) => s.parent == space)) {
|
|
visit(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var space in topLevelSpaces) {
|
|
visit(space);
|
|
}
|
|
|
|
for (var space in spaces) {
|
|
if (!result.contains(space)) {
|
|
result.add(space);
|
|
}
|
|
}
|
|
return result.toList(); // Convert back to a list
|
|
}
|
|
}
|