apply api post action nursery

lib/custom_model/Media.dart

+class Media {
+  String pathFile;
+  bool isVideo;
+  bool isServerFile = false;
+}

lib/data/repository/repository.dart

   //Action
   Future<void> createNursery(Function(dynamic) onSuccess,
       Function(String) onError, String activityNursery,
-      {List<File> files}) async {
-    FormData formData =
-        new FormData.fromMap({"activityNursery": activityNursery});
+      {List<String> filePaths}) async {
+    var formData = FormData();
+    filePaths.forEach((f) {
+      formData.files.add(MapEntry("images", MultipartFile.fromFileSync(f)));
+    });
+    formData.fields.add(MapEntry("activityNursery", activityNursery));
     try {
       await dio
           .post("${ConstCommon.baseUrl}/api/createNursery", data: formData)

lib/presentation/custom_widgets/bloc/media_helper_bloc.dart

+import 'dart:async';
+
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:farm_tpf/custom_model/Media.dart';
+import 'package:meta/meta.dart';
+
+part 'media_helper_event.dart';
+part 'media_helper_state.dart';
+
+class MediaHelperBloc extends Bloc<MediaHelperEvent, MediaHelperState> {
+  MediaHelperBloc() : super(MediaHelperInitial());
+
+  @override
+  Stream<MediaHelperState> mapEventToState(
+    MediaHelperEvent event,
+  ) async* {
+    if (event is ChangeListMedia) {
+      yield MediaHelperSuccess(items: event.items);
+    }
+  }
+}

lib/presentation/custom_widgets/bloc/media_helper_event.dart

+part of 'media_helper_bloc.dart';
+
+abstract class MediaHelperEvent {
+  const MediaHelperEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class ChangeListMedia extends MediaHelperEvent {
+  final List<Media> items;
+  ChangeListMedia({@required this.items});
+}

lib/presentation/custom_widgets/bloc/media_helper_state.dart

+part of 'media_helper_bloc.dart';
+
+abstract class MediaHelperState {
+  const MediaHelperState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class MediaHelperInitial extends MediaHelperState {}
+
+class MediaHelperFailure extends MediaHelperState {
+  final String errorString;
+  MediaHelperFailure({@required this.errorString});
+}
+
+class MediaHelperSuccess extends MediaHelperState {
+  final List<Media> items;
+
+  const MediaHelperSuccess({@required this.items});
+
+  MediaHelperSuccess copyWith({List<Media> items}) {
+    return MediaHelperSuccess(items: items ?? this.items);
+  }
+
+  @override
+  List<Object> get props => [items];
+}

lib/presentation/custom_widgets/widget_media_helper.dart

 import 'dart:io';
 import 'dart:async';
 
+import 'package:farm_tpf/custom_model/Media.dart';
+import 'package:farm_tpf/presentation/custom_widgets/bloc/media_helper_bloc.dart';
 import 'package:farm_tpf/presentation/custom_widgets/hoz_list_view.dart';
 import 'package:farm_tpf/presentation/custom_widgets/shimmer_image.dart';
 import 'package:farm_tpf/utils/const_color.dart';
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:get/get.dart';
+import 'package:get/state_manager.dart';
 import 'package:image_picker/image_picker.dart';
 import 'package:video_player/video_player.dart';
 
 class WidgetMediaHelper extends StatefulWidget {
+  final Function(List<String> filePaths) onChangeFiles;
+  WidgetMediaHelper({@required this.onChangeFiles});
   @override
   _WidgetMediaHelperState createState() => _WidgetMediaHelperState();
 }
 
 class _WidgetMediaHelperState extends State<WidgetMediaHelper> {
+  final globalScaffoldKey = GlobalKey<ScaffoldState>();
   PickedFile _imageFile;
   dynamic _pickImageError;
   bool isVideo = false;
   String _retrieveDataError;
 
   final ImagePicker _picker = ImagePicker();
-  List<ItemMediaVM> items = [];
+  List<Media> currentItems = [];
+  List<String> files = new List<String>();
+  var changeImageController = Get.put(ChangeImageController());
+  double imageWidth = 90;
+  double imageHeight = 90;
 
   @override
-  Widget build(BuildContext context) {
-    return Container(
-        padding: EdgeInsets.all(8),
-        child: Column(
-          children: <Widget>[
-            _actionButton(),
-            SizedBox(
-              height: 4.0,
-            ),
-            _buildListPoster(),
-            defaultTargetPlatform == TargetPlatform.android
-                ? FutureBuilder<void>(
-                    future: retrieveLostData(),
-                    builder:
-                        (BuildContext context, AsyncSnapshot<void> snapshot) {
-                      switch (snapshot.connectionState) {
-                        case ConnectionState.none:
-                        case ConnectionState.waiting:
-                          return const Text(
-                            'You have not yet picked an image.',
-                            textAlign: TextAlign.center,
-                          );
-                        case ConnectionState.done:
-                          return isVideo ? _previewVideo() : _previewImage();
-                        default:
-                          if (snapshot.hasError) {
-                            return Text(
-                              'Pick image/video error: ${snapshot.error}}',
-                              textAlign: TextAlign.center,
-                            );
-                          } else {
-                            return const Text(
-                              'You have not yet picked an image.',
-                              textAlign: TextAlign.center,
-                            );
-                          }
-                      }
-                    },
-                  )
-                : (isVideo ? _previewVideo() : _previewImage()),
-          ],
-        ));
+  void initState() {
+    super.initState();
+    changeImageController.initValue();
   }
 
-  _buildListPoster() {
-    return WrapContentHozListView(
-      itemBuilder: (context, index) {
-        var item = items[index];
-        return _WidgetItemMedia(item);
-      },
-      separatorBuilder: (context, index) {
-        return SizedBox(width: 14);
-      },
-      list: items,
-    );
+  @override
+  Widget build(BuildContext context) {
+    return BlocProvider<MediaHelperBloc>(
+        create: (BuildContext contextA) =>
+            MediaHelperBloc()..add(ChangeListMedia(items: currentItems)),
+        child: BlocBuilder<MediaHelperBloc, MediaHelperState>(
+            builder: (contextB, state) {
+          if (state is MediaHelperFailure) {
+            return Container();
+          } else if (state is MediaHelperSuccess) {
+            return Container(
+                padding: EdgeInsets.all(8),
+                child: Column(
+                  children: <Widget>[
+                    SizedBox(
+                      width: double.infinity,
+                      height: 44,
+                      child: FlatButton(
+                          onPressed: () {
+                            showDialog(
+                                context: context,
+                                barrierDismissible: true,
+                                builder: (context) => Opacity(
+                                      child: multipleChoice(contextB),
+                                      opacity: 1,
+                                    ));
+                          },
+                          color: COLOR_CONST.DEFAULT,
+                          shape: RoundedRectangleBorder(
+                            borderRadius: new BorderRadius.circular(7.0),
+                          ),
+                          child: Center(
+                            child: Row(
+                              mainAxisAlignment: MainAxisAlignment.center,
+                              children: <Widget>[
+                                Icon(Icons.image, color: Colors.white),
+                                SizedBox(
+                                  width: 8.0,
+                                ),
+                                Text(
+                                  button_add_media,
+                                  style: TextStyle(
+                                      fontWeight: FontWeight.bold,
+                                      color: COLOR_CONST.WHITE),
+                                )
+                              ],
+                            ),
+                          )),
+                    ),
+                    SizedBox(
+                      height: 4.0,
+                    ),
+                    Container(
+                      height: 150,
+                      child: _buildListPoster(),
+                    ),
+                    defaultTargetPlatform == TargetPlatform.android
+                        ? FutureBuilder<void>(
+                            future: retrieveLostData(),
+                            builder: (BuildContext context,
+                                AsyncSnapshot<void> snapshot) {
+                              switch (snapshot.connectionState) {
+                                case ConnectionState.none:
+                                case ConnectionState.waiting:
+                                  return const Text(
+                                    'You have not yet picked an image.',
+                                    textAlign: TextAlign.center,
+                                  );
+                                case ConnectionState.done:
+                                  return isVideo
+                                      ? _previewVideo()
+                                      : _previewImage();
+                                default:
+                                  if (snapshot.hasError) {
+                                    return Text(
+                                      'Pick image/video error: ${snapshot.error}}',
+                                      textAlign: TextAlign.center,
+                                    );
+                                  } else {
+                                    return const Text(
+                                      'You have not yet picked an image.',
+                                      textAlign: TextAlign.center,
+                                    );
+                                  }
+                              }
+                            },
+                          )
+                        : (isVideo ? _previewVideo() : _previewImage()),
+                  ],
+                ));
+          }
+          return Container();
+        }));
   }
 
-  Widget viewResult() {
-    FutureBuilder<void>(
-      future: retrieveLostData(),
-      builder: (BuildContext context, AsyncSnapshot<void> snapshot) {
-        switch (snapshot.connectionState) {
-          case ConnectionState.none:
-          case ConnectionState.waiting:
-            return const Text(
-              'You have not yet picked an image.',
-              textAlign: TextAlign.center,
-            );
-          case ConnectionState.done:
-            return isVideo ? _previewVideo() : _previewImage();
-          default:
-            if (snapshot.hasError) {
-              return Text(
-                'Pick image/video error: ${snapshot.error}}',
-                textAlign: TextAlign.center,
-              );
-            } else {
-              return const Text(
-                'You have not yet picked an image.',
-                textAlign: TextAlign.center,
-              );
-            }
-        }
-      },
-    );
+  _buildListPoster() {
+    return BlocBuilder<MediaHelperBloc, MediaHelperState>(
+        builder: (context, state) {
+      if (state is MediaHelperSuccess) {
+        return WrapContentHozListView(
+          itemBuilder: (context, index) {
+            var item = state.items[index];
+            return _WidgetItemMedia(
+                item: item,
+                deleteImage: (item) {
+                  files.remove(item.pathFile);
+                  currentItems.remove(item);
+                  widget.onChangeFiles(files);
+                  BlocProvider.of<MediaHelperBloc>(context)
+                      .add(ChangeListMedia(items: currentItems));
+                });
+          },
+          separatorBuilder: (context, index) {
+            return SizedBox(width: 14);
+          },
+          list: state.items,
+        );
+      }
+      return Container();
+    });
   }
 
-  Widget multipleChoice() {
+  Widget multipleChoice(BuildContext context) {
     return CupertinoAlertDialog(
       title: Text(label_title_select_media),
       actions: <Widget>[
   }
 
   Widget _actionButton() {
-    return SizedBox(
-      width: double.infinity,
-      height: 44,
-      child: FlatButton(
-          onPressed: () {
-            showDialog(
-                context: context,
-                barrierDismissible: true,
-                builder: (context) => Opacity(
-                      child: multipleChoice(),
-                      opacity: 1,
-                    ));
-          },
-          color: COLOR_CONST.DEFAULT,
-          shape: RoundedRectangleBorder(
-            borderRadius: new BorderRadius.circular(7.0),
-          ),
-          child: Center(
-            child: Row(
-              mainAxisAlignment: MainAxisAlignment.center,
-              children: <Widget>[
-                Icon(Icons.image, color: Colors.white),
-                SizedBox(
-                  width: 8.0,
-                ),
-                Text(
-                  button_add_media,
-                  style: TextStyle(
-                      fontWeight: FontWeight.bold, color: COLOR_CONST.WHITE),
-                )
-              ],
+    return BlocListener<MediaHelperBloc, MediaHelperState>(
+        listener: (context, state) {
+      SizedBox(
+        width: double.infinity,
+        height: 44,
+        child: FlatButton(
+            onPressed: () {
+              showDialog(
+                  context: context,
+                  barrierDismissible: true,
+                  builder: (context) => Opacity(
+                        child: Text(""),
+                        opacity: 1,
+                      ));
+            },
+            color: COLOR_CONST.DEFAULT,
+            shape: RoundedRectangleBorder(
+              borderRadius: new BorderRadius.circular(7.0),
             ),
-          )),
-    );
+            child: Center(
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: <Widget>[
+                  Icon(Icons.image, color: Colors.white),
+                  SizedBox(
+                    width: 8.0,
+                  ),
+                  Text(
+                    button_add_media,
+                    style: TextStyle(
+                        fontWeight: FontWeight.bold, color: COLOR_CONST.WHITE),
+                  )
+                ],
+              ),
+            )),
+      );
+    });
   }
 
   Future<void> _playVideo(PickedFile file) async {
       await _controller.initialize();
       await _controller.setLooping(true);
       await _controller.play();
-      setState(() {});
     }
   }
 
-  void _onImageButtonPressed(ImageSource source, {BuildContext context}) async {
+  _onImageButtonPressed(ImageSource source, {BuildContext context}) async {
     if (_controller != null) {
       await _controller.setVolume(0.0);
     }
         try {
           final pickedFile = await _picker.getImage(
             source: source,
-            maxWidth: maxWidth,
-            maxHeight: maxHeight,
+            maxWidth: imageWidth,
+            maxHeight: imageHeight,
             imageQuality: quality,
           );
-          setState(() {
-            _imageFile = pickedFile;
-          });
+
+          Get.find<ChangeImageController>().updateFile(pickedFile);
+          Media newMedia = Media()
+            ..isVideo = false
+            ..isServerFile = false
+            ..pathFile = pickedFile.path;
+          currentItems.add(newMedia);
+          files.add(pickedFile.path);
+          BlocProvider.of<MediaHelperBloc>(context)
+            ..add(ChangeListMedia(items: currentItems));
+          widget.onChangeFiles(files);
         } catch (e) {
-          setState(() {
-            _pickImageError = e;
-          });
+          Get.find<ChangeImageController>().updateFileError(e);
         }
       });
     }
+    ;
   }
 
   @override
   }
 
   Widget _previewImage() {
-    final Text retrieveError = _getRetrieveErrorWidget();
-    if (retrieveError != null) {
-      return retrieveError;
-    }
-    if (_imageFile != null) {
-      var imageResult =
-          Image.file(File(_imageFile.path), width: 100, height: 100);
-      setState(() {
-        items.insert(0, ItemMediaVM(_imageFile.path, false, imageResult));
-      });
-      return Container(
-        child: Text("ok"),
-      );
-    } else if (_pickImageError != null) {
-      return Text(
-        'Pick image error: $_pickImageError',
-        textAlign: TextAlign.center,
-      );
-    } else {
-      return const Text(
-        'You have not yet picked an image.',
-        textAlign: TextAlign.center,
-      );
-    }
+    return Builder(builder: (context) {
+      final Text retrieveError = _getRetrieveErrorWidget();
+      if (retrieveError != null) {
+        return retrieveError;
+      }
+      if (_imageFile != null) {
+        var imageResult =
+            Image.file(File(_imageFile.path), width: imageWidth, height: 100);
+        Media newMedia = Media()
+          ..isVideo = false
+          ..isServerFile = false
+          ..pathFile = _imageFile.path;
+        currentItems.add(newMedia);
+        BlocProvider.of<MediaHelperBloc>(context)
+            .add(ChangeListMedia(items: currentItems));
+        //widget.onChangeFiles(files);
+        return Container(
+          child: Text("ok"),
+        );
+      } else if (_pickImageError != null) {
+        return Text(
+          'Pick image error: $_pickImageError',
+          textAlign: TextAlign.center,
+        );
+      } else {
+        return const Text(
+          'You have not yet picked an image.',
+          textAlign: TextAlign.center,
+        );
+      }
+    });
   }
 
   Future<void> retrieveLostData() async {
 }
 
 class _WidgetItemMedia extends StatelessWidget {
-  final ItemMediaVM item;
+  ItemMediaCallback deleteImage;
+  final Media item;
 
-  _WidgetItemMedia(this.item);
+  _WidgetItemMedia({@required this.item, @required this.deleteImage});
 
   BuildContext _context;
 
             Positioned(
                 child: ClipRRect(
               borderRadius: BorderRadius.circular(8),
-              child: item.image == null
+              child: item.isServerFile
                   ? ShimmerImage(
-                      item.photo,
+                      item.pathFile,
                       width: 93,
                       height: 124,
                       fit: BoxFit.cover,
                     )
-                  : Image.file(File(item.photo), width: 100, height: 100),
+                  : Image.file(File(item.pathFile), width: 100, height: 100),
             )),
             Positioned(
               top: -5,
                   ),
                   onPressed: () {
                     print("On tap delete media");
+                    deleteImage(item);
                   }),
             )
           ],
   }
 }
 
+typedef ItemMediaCallback = void Function(Media item);
+
 class ItemMediaVM {
   String photo;
   bool isVideo;
 
   ItemMediaVM(this.photo, this.isVideo, this.image);
 }
+
+class ChangeImageController extends GetxController {
+  PickedFile _imageFile;
+  dynamic _pickImageError;
+  void initValue() {
+    update();
+  }
+
+  void updateFile(PickedFile imageFile) {
+    _imageFile = imageFile;
+    update();
+  }
+
+  void updateFileError(dynamic pickImageError) {
+    _pickImageError = pickImageError;
+    update();
+  }
+}

lib/presentation/screens/actions/nursery/sc_edit_action_nursery.dart

   bool isResetForm = true;
   final changeSupply = Get.put(ChangeSupply());
   int selectedSupplyId = -1;
+  List<String> filePaths = List<String>();
+  var changeFileController = Get.put(ChangeFileController());
 
   @override
   void initState() {
     super.initState();
     changeSupply.initValue();
+    changeFileController.initValue();
+    filePaths.add(
+        "/Users/macbook/Library/Developer/CoreSimulator/Devices/CC52586C-39AA-489B-A74D-83107AA9F7C1/data/Containers/Data/Application/F377B9A4-939D-42B2-9628-350C4A0BFD50/tmp/image_picker_801FCF0F-577F-4AFA-AC58-1C716A1C561C-30707-000015F0E14256F8.jpg");
     _nursery.nurseryDetail = new List<NurseryDetail>();
     flutterToast = FlutterToast(context);
     //UPDATE
   _validateInputs() async {
     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
+      _nursery.nurseryDetail = currentNurseryDetail;
+      filePaths = Get.find<ChangeFileController>().files;
       var activityNursery = jsonEncode(_nursery.toJson()).toString();
       _repository.createNursery((value) {
         print("post ok");
       }, (error) {
         print("--------------------------------");
         print(error);
-      }, activityNursery);
+      }, activityNursery, filePaths: filePaths);
     } else {
       _autoValidate = true;
     }
   }
 
   Widget _btnAddWorker() {
+    //TODO :check flow error sua item -> xoa list -> bam nut them
     return Builder(builder: (context) {
       return BlocConsumer<StatusAddFormBloc, StatusAddFormState>(
           listener: (context, state) {
                                 SizedBox(
                                   height: 8.0,
                                 ),
-                                WidgetMediaHelper()
+                                WidgetMediaHelper(onChangeFiles: (filePaths) {
+                                  Get.find<ChangeFileController>()
+                                      .addAllFile(filePaths);
+                                  // setState(() {
+                                  //   filePaths = filePaths;
+                                  // });
+                                })
                               ],
                             ),
                           ))))));
     update();
   }
 }
+
+class ChangeFileController extends GetxController {
+  List<String> files;
+  void initValue() {
+    files = [];
+    update();
+  }
+
+  void addAllFile(List<String> filePaths) {
+    files = [];
+    files = filePaths;
+    update();
+  }
+
+  void addFile(String filePath) {
+    files.add(filePath);
+    update();
+  }
+
+  void deleteFile(String filePath) {
+    files.remove(filePath);
+    update();
+  }
+}