329 lines
13 KiB
Dart
329 lines
13 KiB
Dart
import 'dart:io';
|
|
import 'package:file_picker/file_picker.dart';
|
|
import 'package:firebase_storage/firebase_storage.dart';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:manager_app/Components/loading_common.dart';
|
|
import 'package:manager_app/Components/message_notification.dart';
|
|
import 'package:manager_app/Models/managerContext.dart';
|
|
import 'package:manager_app/Screens/Resources/new_resource_popup.dart';
|
|
import 'package:manager_app/Screens/Resources/resource_body_grid.dart';
|
|
import 'package:manager_app/Screens/Resources/show_resource_popup.dart';
|
|
import 'package:manager_app/app_context.dart';
|
|
import 'package:manager_app/constants.dart';
|
|
import 'package:manager_api_new/api.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:path/path.dart' as Path;
|
|
|
|
class ResourcesScreen extends StatefulWidget {
|
|
final Function? onGetResult; //return ResourceDTO
|
|
final bool isImage;
|
|
final bool isAddButton;
|
|
final bool isSelect;
|
|
final bool isRemoveButton;
|
|
final bool isFilter;
|
|
final List<ResourceType> resourceTypes;
|
|
const ResourcesScreen({
|
|
Key? key,
|
|
this.isImage = false,
|
|
this.onGetResult,
|
|
this.isAddButton = true,
|
|
this.isRemoveButton = false,
|
|
this.isSelect = false,
|
|
required this.resourceTypes,
|
|
this.isFilter = true
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
_ResourcesScreenState createState() => _ResourcesScreenState();
|
|
}
|
|
|
|
class _ResourcesScreenState extends State<ResourcesScreen> {
|
|
String? filter;
|
|
bool? isLoading;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final appContext = Provider.of<AppContext>(context);
|
|
Size size = MediaQuery.of(context).size;
|
|
|
|
return FutureBuilder(
|
|
future: getResources(widget.onGetResult, widget.isImage, appContext, widget.resourceTypes),
|
|
builder: (context, AsyncSnapshot<dynamic> snapshot) {
|
|
if (snapshot.connectionState == ConnectionState.done) {
|
|
if(snapshot.data != null) {
|
|
List<ResourceDTO> tempOutput = [];
|
|
if(widget.isRemoveButton) {
|
|
tempOutput.add(ResourceDTO());
|
|
tempOutput.addAll(new List<ResourceDTO>.from(snapshot.data));
|
|
} else {
|
|
tempOutput = new List<ResourceDTO>.from(snapshot.data);
|
|
}
|
|
|
|
return ResourceBodyGrid(
|
|
resources: tempOutput,
|
|
resourceTypesIn: widget.isImage ? resource_types.where((rt) => rt.type == ResourceType.Image || rt.type == ResourceType.ImageUrl).map((rt) => rt.type).toList() : widget.resourceTypes,
|
|
isAddButton: widget.isAddButton,
|
|
onSelect: (value) async {
|
|
if(widget.isSelect) {
|
|
if (value.id == null && widget.isAddButton) {
|
|
List<dynamic>? result = await showNewResource(appContext, context);
|
|
if (result != null)
|
|
{
|
|
await create(result[0], result[1], result[2], appContext, context);
|
|
Future.delayed(Duration(seconds: 2), () {
|
|
setState(() {});
|
|
});
|
|
// For refresh
|
|
}
|
|
} else {
|
|
// Result for select modal
|
|
widget.onGetResult!(value);
|
|
}
|
|
} else {
|
|
if (widget.onGetResult == null) {
|
|
// Main screen
|
|
if (value.id == null) {
|
|
List<dynamic>? result = await showNewResource(appContext, context);
|
|
if (result != null)
|
|
{
|
|
await create(result[0], result[1], result[2], appContext, context);
|
|
Future.delayed(Duration(seconds: 2), () {
|
|
setState(() {});
|
|
});
|
|
// For refresh
|
|
}
|
|
} else {
|
|
var result = await showResource(value, appContext, context, size);
|
|
if(result != null) {
|
|
// Update resource
|
|
ManagerAppContext managerAppContext = appContext.getContext() as ManagerAppContext;
|
|
try{
|
|
var resourceUpdated = managerAppContext.clientAPI!.resourceApi!.resourceUpdate(result);
|
|
setState(() {
|
|
// refresh ui
|
|
showNotification(kSuccess, kWhite, 'La ressource a été mise à jour avec succès', context, null);
|
|
});
|
|
} catch (e) {
|
|
print("Error during updating resource");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Result for select modal
|
|
widget.onGetResult!(value);
|
|
}
|
|
}
|
|
});//bodyGrid(tempOutput, size, appContext);
|
|
} else {
|
|
return Text("No data");
|
|
}
|
|
} else if (snapshot.connectionState == ConnectionState.none) {
|
|
return Text("No data");
|
|
} else {
|
|
return Center(
|
|
child: Container(
|
|
height: size.height * 0.2,
|
|
child: LoadingCommon()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<List<ResourceDTO>?> getResources(Function? onGetResult, bool isImage, AppContext appContext, List<ResourceType> types) async {
|
|
types = types != null ? types : [];
|
|
List<ResourceDTO>? resources = await (appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.resourceGet(instanceId: (appContext.getContext() as ManagerAppContext).instanceId, types: types);
|
|
if (onGetResult != null && isImage && resources != null) {
|
|
resources = resources.where((element) => element.type == ResourceType.Image || element.type == ResourceType.ImageUrl || element.type == ResourceType.Audio).toList();
|
|
}
|
|
return resources;
|
|
}
|
|
|
|
Future<List<ResourceDTO?>?> create(ResourceDTO resourceDTO, List<File>? files, List<PlatformFile>? filesWeb, AppContext appContext, context) async {
|
|
List<ResourceDTO?> createdResources = [];
|
|
print("Coucou create");
|
|
print(resourceDTO);
|
|
|
|
ManagerAppContext managerAppContext = appContext.getContext();
|
|
int index = 0;
|
|
|
|
if(filesWeb != null) {
|
|
for (PlatformFile platformFile in filesWeb) {
|
|
var mimeType = "";
|
|
print("Coucou platformFile");
|
|
print(platformFile);
|
|
print(platformFile.name);
|
|
print(platformFile.extension);
|
|
ResourceDTO resourceDTO = new ResourceDTO(label: platformFile.name);
|
|
switch(platformFile.extension) {
|
|
case 'jpg':
|
|
case 'jpeg':
|
|
case 'png':
|
|
case 'gif':
|
|
resourceDTO.type = ResourceType.Image;
|
|
mimeType = 'image/'+platformFile.extension!;
|
|
break;
|
|
case 'mp3':
|
|
resourceDTO.type = ResourceType.Audio;
|
|
mimeType = 'audio/'+platformFile.extension!;
|
|
break;
|
|
case 'mp4':
|
|
resourceDTO.type = ResourceType.Video;
|
|
mimeType = 'video/'+platformFile.extension!;
|
|
break;
|
|
case 'webm':
|
|
resourceDTO.type = ResourceType.Video;
|
|
mimeType = 'video/'+platformFile.extension!;
|
|
break;
|
|
case 'pdf':
|
|
resourceDTO.type = ResourceType.Pdf;
|
|
mimeType = 'application/'+platformFile.extension!;
|
|
break;
|
|
case 'json':
|
|
resourceDTO.type = ResourceType.Json;
|
|
mimeType = 'application/'+platformFile.extension!;
|
|
break;
|
|
}
|
|
resourceDTO.instanceId = managerAppContext.instanceId;
|
|
try {
|
|
print("Trying to create resource");
|
|
// ADD LOADING
|
|
resourceDTO.dateCreation = DateTime.now();
|
|
ResourceDTO? newResource = await managerAppContext.clientAPI!.resourceApi!.resourceCreate(resourceDTO);
|
|
print("created resource");
|
|
print(newResource);
|
|
if(newResource != null && resourceDTO.type != null) {
|
|
FirebaseStorage storage = FirebaseStorage.instance;
|
|
Reference ref = storage.ref().child('pictures/${appContext.getContext().instanceId}/${Path.basename(newResource.id!.toString())}');
|
|
|
|
var metadata = SettableMetadata(
|
|
contentType: mimeType, // ou le type MIME approprié pour votre fichier
|
|
);
|
|
|
|
UploadTask uploadTask = ref.putData(platformFile.bytes!, metadata);
|
|
uploadTask.then((res) {
|
|
res.ref.getDownloadURL().then((urlRessource) {
|
|
showNotification(Colors.green, kWhite, 'La ressource a été créée avec succès', context, null);
|
|
newResource.url = urlRessource;
|
|
(appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.resourceUpdate(newResource);
|
|
createdResources.add(newResource);
|
|
index++;
|
|
if(index == filesWeb.length) {
|
|
return createdResources;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
} catch(e) {
|
|
print("ERROR creating resource");
|
|
print(e);
|
|
}
|
|
}
|
|
} else {
|
|
// online resource
|
|
print("Trying to create resource");
|
|
resourceDTO.dateCreation = DateTime.now();
|
|
resourceDTO.label = "Resource en ligne";
|
|
resourceDTO.instanceId = managerAppContext.instanceId;
|
|
ResourceDTO? newResource = await managerAppContext.clientAPI!.resourceApi!.resourceCreate(resourceDTO);
|
|
print("created resource");
|
|
createdResources.add(newResource);
|
|
return createdResources;
|
|
}
|
|
|
|
return null;
|
|
|
|
/*switch(resourceDTO.type) {
|
|
case ResourceType.Audio:
|
|
case ResourceType.Image:
|
|
case ResourceType.Video:
|
|
|
|
var request = http.MultipartRequest('POST', Uri.parse((appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.apiClient.basePath+"/api/Resource/upload"));
|
|
|
|
if (kIsWeb) {
|
|
for (PlatformFile file in filesWeb!) {
|
|
request.files.add(
|
|
await http.MultipartFile.fromBytes(
|
|
'picture',
|
|
file.bytes!,
|
|
filename: file.name
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
for (File file in files!) {
|
|
request.files.add(
|
|
await http.MultipartFile(
|
|
'picture',
|
|
file.readAsBytes().asStream(),
|
|
file.lengthSync(),
|
|
filename: file.path.toString().split("/").last
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
ManagerAppContext managerAppContext = appContext.getContext();
|
|
request.headers["authorization"]="Bearer ${managerAppContext.accessToken}";
|
|
request.fields['label'] = resourceDTO.label!;
|
|
request.fields['type'] = resourceDTO.type.toString();
|
|
request.fields['instanceId'] = managerAppContext.instanceId!;
|
|
|
|
var res = await request.send();
|
|
await res.stream.bytesToString();
|
|
|
|
if (res.statusCode == 200) {
|
|
// TODO just create resource ref with download url from followed
|
|
try {
|
|
for (PlatformFile platformFile in filesWeb!) {
|
|
resourceDTO.instanceId = (appContext.getContext() as ManagerAppContext).instanceId;
|
|
ResourceDTO? newResource = await (appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.resourceCreate(resourceDTO);
|
|
|
|
if(newResource != null) {
|
|
FirebaseStorage storage = FirebaseStorage.instance;
|
|
Reference ref = storage.ref().child('pictures/${appContext.getContext().instanceId}/${Path.basename(newResource.id!.toString())}');
|
|
|
|
UploadTask uploadTask = ref.putData(platformFile.bytes!);
|
|
uploadTask.then((res) {
|
|
res.ref.getDownloadURL().then((urlImage) {
|
|
showNotification(Colors.green, kWhite, 'La ressource a été créée avec succès', context, null);
|
|
newResource.url = urlImage;
|
|
(appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.resourceUpdate(newResource);
|
|
return newResource;
|
|
});
|
|
});
|
|
}
|
|
showNotification(Colors.orange, kWhite, 'Une erreur est survenue lors de la création de la ressource', context, null);
|
|
return null;
|
|
}
|
|
} catch (e) {
|
|
print('Error uploading file: $e');
|
|
}
|
|
return null;
|
|
} else {
|
|
showNotification(kPrimaryColor, kWhite, 'Erreur, attention, la taille de la ressource doit être inférieure à 1.5Mb', context, null);
|
|
}
|
|
break;
|
|
case ResourceType.ImageUrl:
|
|
case ResourceType.VideoUrl:
|
|
if (resourceDTO.url != null) {
|
|
// test if Correct url
|
|
bool _validURL = Uri.parse(resourceDTO.url!).isAbsolute;
|
|
if(_validURL) {
|
|
resourceDTO.instanceId = (appContext.getContext() as ManagerAppContext).instanceId;
|
|
ResourceDTO? newResource = await (appContext.getContext() as ManagerAppContext).clientAPI!.resourceApi!.resourceCreate(resourceDTO);
|
|
showNotification(Colors.green, kWhite, 'La ressource a été créée avec succès', context, null);
|
|
|
|
return newResource;
|
|
} else {
|
|
showNotification(Colors.orange, kWhite, 'L\'url est invalide', context, null);
|
|
}
|
|
} else {
|
|
showNotification(Colors.orange, kWhite, 'Veuillez remplir le champ URL', context, null);
|
|
}
|
|
break;
|
|
}*/
|
|
} |