create table

lib/infrastructure/table/datasources/remote_data_provider.dart

@@ -44,6 +44,38 @@ class TableRemoteDataProvider {
     }
   }
 
+  Future<DC<TableFailure, TableDto>> storeTable({
+    required String outletId,
+    required String name,
+    required int capacity,
+  }) async {
+    try {
+      final response = await _apiClient.post(
+        ApiPath.tables,
+        data: {
+          'outlet_id': outletId,
+          'table_name': name,
+          'capacity': capacity,
+          'position_x': 200,
+          'position_y': 200,
+        },
+        headers: getAuthorizationHeader(),
+      );
+
+      if (response.data['success'] == false) {
+        return DC.error(TableFailure.unexpectedError());
+      }
+
+      final table = TableDto.fromJson(
+        response.data['data'] as Map<String, dynamic>,
+      );
+      return DC.data(table);
+    } on ApiFailure catch (e, s) {
+      log('storeTableError', name: _logName, error: e, stackTrace: s);
+      return DC.error(TableFailure.serverError(e));
+    }
+  }
+
   Future<DC<TableFailure, TableDto>> updatePosition({
     required String id,
     required Offset position,

lib/infrastructure/table/repositories/table_repository.dart

@@ -5,14 +5,16 @@ import 'package:dartz/dartz.dart';
 import 'package:injectable/injectable.dart';
 
 import '../../../domain/table/table.dart';
+import '../../outlet/datasources/local_data_provider.dart';
 import '../datasources/remote_data_provider.dart';
 
 @Injectable(as: ITableRepository)
 class TableRepository implements ITableRepository {
   final TableRemoteDataProvider _remoteDataProvider;
+  final OutletLocalDatasource _outletLocalDatasource;
   final _logName = 'TableRepository';
 
-  TableRepository(this._remoteDataProvider);
+  TableRepository(this._remoteDataProvider, this._outletLocalDatasource);
 
   @override
   Future<Either<TableFailure, ListTable>> fetchTables({
@@ -38,6 +40,33 @@ class TableRepository implements ITableRepository {
     }
   }
 
+  @override
+  Future<Either<TableFailure, Table>> createTable({
+    required String name,
+    required int capacity,
+  }) async {
+    try {
+      final outlet = await _outletLocalDatasource.currentOutlet();
+
+      final result = await _remoteDataProvider.storeTable(
+        outletId: outlet.id,
+        name: name,
+        capacity: capacity,
+      );
+
+      if (result.hasError) {
+        return left(result.error!);
+      }
+
+      final table = result.data!.toDomain();
+
+      return right(table);
+    } catch (e) {
+      log('fetchCreateTable', name: _logName, error: e);
+      return left(const TableFailure.unexpectedError());
+    }
+  }
+
   @override
   Future<Either<TableFailure, Table>> updatePosition({
     required String id,