salim-lachdhaf / dartftp Goto Github PK

import 'package:ftpconnect/ftpconnect.dart';

main() async {
  FTPConnect ftpConnect = FTPConnect('example.com', user: 'user', pass: 'pass');
  
  await ftpConnect.connect();
  
  List<String> DirectoryContent = await ftpConnect.listDirectoryContentOnlyNames();

  print('DirectoryContent: $DirectoryContent');

  await ftpConnect.disconnect();
}

final ftp = FTPConnect(
  '10.22.3.185',
  port: 990,
  user: 'asdf',
  pass: 'asdfasdf',
  securityType: SecurityType.FTPS,
  timeout: 3,
);
await ftp.connect();

        // await ftpConnect.connect();

        currentIndex = i;
        if (cancelUpload.value == false && isUploadSucess.value == false) {
          log("lenfth of file" + file.length.toString());
          log("current file path:" + file[i].path);
          File files = File(file[i].path);
          log("current file path ---->> :" + files.path);
          log("current file paths before uploading :" +
              tabController1.file.toString());

          await ftpConnect.uploadFile(
            File(file[i].path),
            supportIPV6: false,
          );
          double data1 = fileCount.value.toDouble();
          showFileCount.value = data1.toString();
          //increase the value of file by one when the file is uploaded sucessfully
          //below code is to calculate upload percent
          log("file count" + fileCount.value.toString());
          showUploadPercentage.value = uploadPercent.value;
          //uploading xml file
          String fileName = p.basename(file[i].path).split('.').first;
          // remove extension from file name
          // fileName = fileName.substring(0, fileName.lastIndexOf('.'));
          //faster way

          final myxmlFile = File('$_dirPath/${fileName}.xml');
          log("XML FILE NAME >>>> ${myxmlFile.path}");
          await myxmlFile.writeAsString(document.toXmlString(pretty: true));
          await ftpConnect.uploadFile(myxmlFile);
          fileCount.value++;
          uploadPercent.value =
              (fileCount.value.toDouble() / totalcount) * 100;
          double data = fileCount.value.toDouble();
          showFileCount.value = data.toString();
          log("file count" + fileCount.value.toString());
          log("totalFileCount" + totalFileCount.value.toString());
          log("upload percent" + uploadPercent.value.toString());
          log("above sucess" + uploadPercent.value.toString());
          showUploadPercentage.value = uploadPercent.value;
          // await ftpConnect.disconnect();
          if (showUploadPercentage.value == 100.0) {
            Wakelock.disable();
            isUploadSucess.value = true;
            Fluttertoast.showToast(
                msg: "Successfully Uploaded".tr,
                gravity: ToastGravity.CENTER);

            log("upload was" + isUploadSucess.toString());
          }
        } else if (cancelUpload.value == true) {
          Fluttertoast.showToast(
              msg: "Upload was canceled", gravity: ToastGravity.CENTER);
        }
      }

I/flutter (29447): [2024-05-17 16:59:18.494143] Download /80/STM6001_DIA_001/SITE80_STM6001_DIA_001_2023-3-30T9_59_31.jpeg to /data/user/0/<APP ID PURPOSELY HIDDEN>/app_flutter/ftpfiles/SITE80_STM6001_DIA_001_2023-3-30T9_59_31.jpeg
I/flutter (29447): [2024-05-17 16:59:18.495056] > SIZE /80/STM6001_DIA_001/SITE80_STM6001_DIA_001_2023-3-30T9_59_31.jpeg
I/flutter (29447): [2024-05-17 16:59:18.800862] < FTPReply =  [code= 213, message= 213 135512]
I/flutter (29447): [2024-05-17 16:59:18.802551] > EPSV
I/flutter (29447): [2024-05-17 16:59:19.110779] < FTPReply =  [code= 229, message= 229 Extended Passive mode OK (|||40092|)]
I/flutter (29447): [2024-05-17 16:59:19.111523] > RETR /80/STM6001_DIA_001/SITE80_STM6001_DIA_001_2023-3-30T9_59_31.jpeg
I/flutter (29447): [2024-05-17 16:59:19.112454] Opening DataSocket to Port 40092
I/flutter (29447): [2024-05-17 16:59:19.442433] < FTPReply =  [code= 226, message= 150-Accepted data connection
I/flutter (29447): 150 132.3 kbytes to download
I/flutter (29447): 226-File successfully transferred
I/flutter (29447): 226 0.000 seconds (measured here), 282.76 Mbytes per second]
I/flutter (29447): [2024-05-17 16:59:19.445156] Start downloading...

Future<File> _createFile() async {
    final now = DateTime.now();
    final formatter = DateFormat('yyyy-MM-dd_HH-mm-ss');
    final fileName = 'archivo_${formatter.format(now)}.txt';
    final file = await _localFile(fileName);
    if (!file.existsSync()) {
      file.createSync(recursive: true);
    }
    return file;
  }

Future<void> _uploadFileToFTP(File fileToUpload) async {
  FTPConnect ftpConnect = FTPConnect('000.000.0.000', user: 'Rrrrrrr', pass: '333333');

  try {
    await ftpConnect.connect();
    await ftpConnect.uploadFileWithRetry(fileToUpload, pRetryCount: 2);
  } catch (e) {
    print('Error al subir el archivo al servidor FTP: $e');
  } finally {
    await ftpConnect.disconnect();
  }
}

void _guardarDatos() async {
  if (_formKey.currentState!.validate()) {
    final codigoInterno = _codigoInternoController.text;
    final kilometraje = _kilometrajeController.text;
    final observaciones = _observacionesController.text;

    final file = await _createFile();
    final sink = file.openWrite(mode: FileMode.append);
    sink.write('Código Interno: $codigoInterno\n');
    sink.write('Kilometraje u Horómetro: $kilometraje\n');
    sink.write('Observaciones: $observaciones\n');
    sink.write('\n');
    await sink.flush();
    await sink.close();

    await _uploadFileToFTP(file);

    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text('Datos guardados correctamente.')),
    );
  }
}

await dataSocket.listen((data) {
      sink.add(data);
      if (onProgress != null) {
        received += data.length;
        var percent = ((received / fileSize) * 100).toStringAsFixed(2);
        //in case that the file size is 0, then pass directly 100
        double percentVal = double.tryParse(percent) ?? 100;
        if (percentVal.isInfinite || percentVal.isNaN) percentVal = 100;
        onProgress(percentVal, received, fileSize);
      }
    }).asFuture();

///mock a file for the demonstration example
const  X=<int>[];   // added by me as input of List<int> to function below

return file;

  await _ftpConnect.connect();

  await _log('Downloading ...');
  String fileName = '../message2.wav';

  //here we just prepare a file as a path for the downloaded file
  File downloadedFile = await _fileMockwav(fileName: 'DownloadedStepByStep.wav');
  await _ftpConnect.downloadFile(fileName, downloadedFile);
  await _log('file downloaded path: ${downloadedFile.path}');
  await _ftpConnect.disconnect();
} catch (e) {
  await _log('Downloading FAILED: ${e.toString()}');
}

final ftpConnect = FTPConnect(event.configFtp.address, user: event.configFtp.username, pass: event.configFtp.password, port: 21);
  ftpConnect.listCommand = ListCommand.LIST;
  await ftpConnect.connect();
  await ftpConnect.listDirectoryContentOnlyNames();

E/flutter ( 9458): [ERROR:flutter/runtime/dart_vm_initializer.cc(41)] Unhandled Exception: FormatException: Trying to read MMM from May 28 19:50 2023 at 0
E/flutter ( 9458): #0      _DateFormatField.throwFormatException (package:intl/src/intl/date_format_field.dart:87:5)
E/flutter ( 9458): #1      _DateFormatPatternField.parseField (package:intl/src/intl/date_format_field.dart:350:7)
E/flutter ( 9458): #2      _DateFormatPatternField.parse (package:intl/src/intl/date_format_field.dart:261:5)
E/flutter ( 9458): #3      DateFormat._parse (package:intl/src/intl/date_format.dart:384:13)
E/flutter ( 9458): #4      DateFormat.parse (package:intl/src/intl/date_format.dart:315:7)
E/flutter ( 9458): #5      new FTPEntry._parseLIST (package:ftpconnect/src/ftp_entry.dart:198:40)
E/flutter ( 9458): #6      new FTPEntry._parseListCommand (package:ftpconnect/src/ftp_entry.dart:150:23)
E/flutter ( 9458): #7      new FTPEntry.parse (package:ftpconnect/src/ftp_entry.dart:56:23)
E/flutter ( 9458): #8      FTPDirectory.directoryContent.<anonymous closure> (package:ftpconnect/src/commands/directory.dart:86:20)
E/flutter ( 9458): #9      List.forEach (dart:core-patch/growable_array.dart:416:8)
E/flutter ( 9458): #10     FTPDirectory.directoryContent (package:ftpconnect/src/commands/directory.dart:83:59)
E/flutter ( 9458): <asynchronous suspension>
E/flutter ( 9458): #11     FTPDirectory.directoryContentNames (package:ftpconnect/src/commands/directory.dart:95:16)
E/flutter ( 9458): <asynchronous suspension>
E/flutter ( 9458): #12     FtpBloc._onFtpConnect (package:remanfredi/presentation/transport/bloc/ftp_bloc.dart:31:21)
E/flutter ( 9458): <asynchronous suspension>
E/flutter ( 9458): #13     Bloc.on.<anonymous closure>.handleEvent (package:bloc/src/bloc.dart:229:13)
E/flutter ( 9458): <asynchronous suspension>
E/flutter ( 9458):

      status = "DL: ${percent}%";
      if (stop) {
        ftpConnect.sendCustomCommand("QUIT");
        ftpConnect.disconnect();
        downloading = false;
        percent = 0.0;
        done = false;
        stop = false;
        notifyListeners();
      }
      notifyListeners();
    },
  );

isDownloading = true;
downloadProgress = 0.0;

print("Downloading files...");
List<Map<String, dynamic>> allDeliveryLogs = [];

try {
  print("Connecting to FTP server...");

  // Assuming you have an initialized FTP client stored in the variable ftpConnect
  // ...

  print("Changing directory...");
  await ftpConnect!
      .changeDirectory('/ftp/DeliverEsignService/1472589/A/Import/');

  print("Retrieving directory content...");
  final directoryContent = await ftpConnect!.listDirectoryContent();
  print("FTP Server Response: $directoryContent");

  print("Filtering file names...");
  final fileNames = directoryContent
      .where((entry) => entry.name.toLowerCase().endsWith('.db'))
      .map((entry) => entry.name)
      .toList();

  print('File names found: $fileNames');
  if (fileNames.isEmpty) {
    print('No files found for download.');
  }

  // Download and store each file locally
  for (int i = 0; i < fileNames.length; i++) {
    String fileName = fileNames[i];
    print('Processing file $i: $fileName');

    String serverFilePath =
        '/ftp/DeliverEsignService/1472589/A/Import/$fileName';

    // Get the local app directory path using path_provider
    Directory appDir = await getApplicationDocumentsDirectory();
    String localFilePath = '${appDir.path}/$fileName';
    File localFile = File(localFilePath);

    print('Downloading file: $fileName');

    try {
      await ftpConnect?.downloadFileWithRetry(
        serverFilePath,
        localFile,
        onProgress: (progress, received, total) {
          print('Download progress: $progress ($received / $total)');

          downloadProgress = progress;
        },
      );

      print('File downloaded successfully: $fileName');

      // Open the database
      Database database = await openDatabase(localFilePath);

      // Print the schema of the 'deliveryLog' table
      List<Map<String, dynamic>> columns =
          await database.rawQuery("PRAGMA table_info('deliveryLog')");
      print('Table Schema: $columns');

      // Retrieve the data from the SQLite database
      List<Map<String, dynamic>> deliveryLogsData =
          await database.rawQuery('SELECT * FROM deliveryLog');
      print('deliveryLogs: $deliveryLogsData');

      // Create a List of DeliveryLog objects from the database data
      List<DeliveryLog> deliveryLogs = deliveryLogsData
          .map((data) => DeliveryLog(
                recordId: data['recordId'],
                patientID: data['PatientID'],
                nursingHomeID: data['NurshingHomeID'],
                rxID: data['RxID'],
                driverID: data['DriverID'],
                rxNumber: data['RxNumber'],
                fillDate: data['Fill_Date'],
                patientName: data['Patient_Name'],
                address: data['Address'],
                nursingHomeName: data['Nursing_Home_Name'],
                drug: data['Drug'],
                status: data['Status'],
                recipient: data['Recipient'],
                sign: data['Sign'],
                deliveredDateTime: data['Delivered_Date_Time'],
                amount:
                    data['Amount'], // Convert to double if it's not null
                paymentType: data['PaymentType'],
                paymentAmount: data[
                    'PaymentAmount'], // Convert to double if it's not null
              ))
          .toList();

      // Convert List<DeliveryLog> to List<Map<String, dynamic>>
      List<Map<String, dynamic>> deliveryLogsMapList =
          deliveryLogs.map((log) => log.toMap()).toList();

      // Add the delivery logs to the list
      allDeliveryLogs.addAll(deliveryLogsMapList);

      // Store the deliveryLogs in Hive
      await storeUniqueLogsInHive(deliveryLogs);

      // Close the database connection
      await database.close();
    } catch (e) {
      closeCustomLoadingDialog();
      showCustomSnackBar('Error downloading file: $fileName - $e');
      // Delete the corrupted file
      await localFile.delete();
      print('Corrupted file deleted: $fileName');
    }
  }
} catch (e) {
  closeCustomLoadingDialog();
  showCustomSnackBar("Error: $e");
  print(e);
} finally {
  closeCustomLoadingDialog();
  print("Disconnecting from FTP server...");
  await ftpConnect?.disconnect();

  isDownloading = false;
  downloadProgress = 0.0;
}

ftpConnect!.listDirectoryContent(cmd: DIR_LIST_COMMAND.LIST)

  /// Returns the content of the current directory
  /// [cmd] refer to the used command for the server, there is servers working
  /// with MLSD and other with LIST
  Future<List<FTPEntry>> listDirectoryContent() {
    return FTPDirectory(_socket).directoryContent();
  }

FTPConnectException: Connection refused.  (Response: 500 Unknown command.)

Future<bool> guardarImagenFTP({required String ruta}) async {
    try {
      print('INICIO DE GUARDAR IMAGENEN FTP ...');
      final ftpConnect = FTPConnect('SERVER',
          user: 'USER', pass: 'PASSWORD');
      await ftpConnect.changeDirectory('/DIR1/DIR2/DIR3');
      final fileToUpload = File(ruta);
      print('CONECTANDO A FTP ...');
      await ftpConnect.connect();
      print('SUBIENDO IMAGEN...');
      final res = await ftpConnect.uploadFile(fileToUpload);
      await ftpConnect.disconnect();
      return res;
    } catch (e) {
      print('Error uploading file: ${e.toString()}');
      return false;
    }
  }