Holzleitner-Lieferservice-App/lib/feature/delivery/detail/service/notes_service.dart

import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:hl_lieferservice/dto/note_get_response.dart';
import 'package:hl_lieferservice/services/erpframe.dart';
import 'package:docuframe/docuframe.dart' as df;
import 'package:flutter/cupertino.dart';
import 'package:http/http.dart' as http;

import '../../../../dto/basic_response.dart';
import '../../../../dto/note_add_response.dart';
import '../../../../dto/note_template_response.dart';
import '../../../../model/delivery.dart';

class NoteService extends ErpFrameService {
  NoteService({required super.config});

  Future<void> deleteNote(int noteId) async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute("_web_deleteNote", parameter: {"id": noteId});

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      BasicResponseDTO responseDto = BasicResponseDTO.fromJson(responseJson);

      if (responseDto.succeeded == true) {
        return;
      } else {
        throw responseDto.message;
      }
    } catch (e, st) {
      debugPrint("ERROR WHILE DELETING NOTE $noteId");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<void> editNote(Note newNote) async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute(
        "_web_editNote",
        parameter: {"id": newNote.id, "note": newNote.content},
      );

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      BasicResponseDTO responseDto = BasicResponseDTO.fromJson(responseJson);

      if (responseDto.succeeded == true) {
        return;
      } else {
        throw responseDto.message;
      }
    } catch (e, st) {
      debugPrint("ERROR WHILE EDITING NOTE ${newNote.id}");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<List<NoteTemplate>> getNoteTemplates() async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute("_web_getNoteTemplates");

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      NoteTemplateResponseDTO responseDto = NoteTemplateResponseDTO.fromJson(
        responseJson,
      );

      if (responseDto.succeeded == true) {
        return responseDto.notes.map(NoteTemplate.fromDTO).toList();
      } else {
        throw responseDto.message;
      }
    } catch (e, st) {
      debugPrint("ERROR WHILE GETTING NOTE TEMPLATES");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<List<Note>> getNotes(String deliveryId) async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute("_web_getNotes", parameter: {"delivery_id": deliveryId});
      debugPrint(deliveryId);

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      debugPrint(responseJson.toString());
      NoteGetResponseDTO responseDto = NoteGetResponseDTO.fromJson(
        responseJson,
      );

      if (responseDto.succeeded == true) {
        return responseDto.notes
            .map((noteDto) => Note.fromDto(noteDto))
            .toList();
      } else {
        throw responseDto.message;
      }
    } catch (e, st) {
      debugPrint("ERROR WHILE GETTING NOTES");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<Note> addNote(String note, int deliveryId) async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute(
        "_web_addNote",
        parameter: {"receipt_id": deliveryId, "note": note},
      );

      debugPrint(deliveryId.toString());

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      debugPrint(responseJson.toString());
      NoteAddResponseDTO responseDto = NoteAddResponseDTO.fromJson(
        responseJson,
      );

      if (responseDto.succeeded == true) {
        return Note.fromDto(responseDto.note!);
      } else {
        debugPrint("ERROR: ${responseDto.message}");
        throw responseDto.message;
      }
    } catch (e) {
      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<String> uploadImage(
    String deliveryId,
    String filename,
    Uint8List bytes,
    String? mimeType,
  ) async {
    df.LoginSession? session;

    try {
      session = await getSession();

      // First get UPLOAD ID
      df.UploadFile uploadHandler = df.UploadFile(
        config: dfConfig,
        session: session,
      );
      df.GetUploadIdResponse uploadIdResponse =
          await uploadHandler.getUploadId();

      // Upload binary data to DOCUframe
      debugPrint(filename);
      df.FileInformationResponse response = await uploadHandler.uploadFile(
        uploadIdResponse.uploadId,
        bytes,
        filename,
        mimeType ?? "image/jpeg",
      );
      debugPrint(response.body);

      // Commit file upload
      df.CommitFileUploadResponse commitResponse = await uploadHandler
          .commitUpload(uploadIdResponse.uploadId);
      debugPrint(commitResponse.body);

      return commitResponse.objectId;
    } catch (e, st) {
      debugPrint("An error occured:");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<List<Future<Uint8List>>> downloadImages(List<String> urls) async {
    df.LoginSession? session;

    debugPrint(urls.toString());

    try {
      session = await getSession();

      final header = {
        "sessionId": session.getAuthorizationHeader().$2,
        "appKey": config.appNames[0],
      };

      return urls.map((url) async {
        return (await http.get(
          Uri.parse("${config.host}$url"),
          headers: header,
        )).bodyBytes;
      }).toList();
    } catch (e, st) {
      debugPrint("An error occured:");
      debugPrint("$e");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }

  Future<void> removeImage(String oid) async {
    df.LoginSession? session;

    try {
      session = await getSession();
      df.DocuFrameMacroResponse response = await df.Macro(
        config: dfConfig,
        session: session,
      ).execute("_web_removeImage", parameter: {"oid": oid});

      Map<String, dynamic> responseJson = jsonDecode(response.body!);
      debugPrint(oid);
      debugPrint(responseJson.toString());

      BasicResponseDTO responseDto = BasicResponseDTO.fromJson(responseJson);

      if (responseDto.succeeded == true) {
        return;
      } else {
        debugPrint("ERROR: ${responseDto.message}");
        throw responseDto.message;
      }
    } on df.DocuFrameException catch (e, st) {
      debugPrint("${e.errorMessage}");
      debugPrint(st.toString());

      rethrow;
    } finally {
      await logout(session);
    }
  }
}