411 lines
12 KiB
Dart
411 lines
12 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'dart:convert';
|
|
import 'dart:ui_web' as ui;
|
|
import 'dart:html' as html;
|
|
|
|
class MailAddress {
|
|
final String? name;
|
|
final String address;
|
|
MailAddress({this.name, required this.address});
|
|
|
|
factory MailAddress.fromJson(Map<String, dynamic> json) {
|
|
return MailAddress(
|
|
name: json['name'],
|
|
address: json['address'],
|
|
);
|
|
}
|
|
}
|
|
|
|
class SerializableMessage {
|
|
final String name;
|
|
final String from;
|
|
final List<MailAddress> to;
|
|
final List<MailAddress> cc;
|
|
final String hash;
|
|
|
|
// final String path;
|
|
final String subject;
|
|
final String date;
|
|
final int uid;
|
|
final String list;
|
|
final String id;
|
|
final String in_reply_to;
|
|
|
|
SerializableMessage({
|
|
required this.name,
|
|
required this.from,
|
|
required this.to,
|
|
required this.cc,
|
|
required this.hash,
|
|
required this.subject,
|
|
required this.date,
|
|
required this.uid,
|
|
required this.list,
|
|
required this.id,
|
|
required this.in_reply_to,
|
|
});
|
|
|
|
factory SerializableMessage.fromJson(Map<String, dynamic> json) {
|
|
var toList = json['to'] as List;
|
|
var ccList = json['cc'] as List;
|
|
|
|
return SerializableMessage(
|
|
name: json['name'],
|
|
from: json['from'],
|
|
// to: json['name', 'address']
|
|
to: toList.map((i) => MailAddress.fromJson(i)).toList(),
|
|
cc: ccList.map((i) => MailAddress.fromJson(i)).toList(),
|
|
// path: json['path'],
|
|
hash: json['hash'],
|
|
subject: json['subject'],
|
|
date: json['date'],
|
|
uid: json['uid'],
|
|
list: json['list'],
|
|
id: json['id'],
|
|
in_reply_to: json['in_reply_to'],
|
|
);
|
|
}
|
|
}
|
|
|
|
class EmailPage extends StatefulWidget {
|
|
const EmailPage({super.key});
|
|
final String title = 'Emails';
|
|
|
|
@override
|
|
State<EmailPage> createState() => _EmailPageState();
|
|
}
|
|
|
|
class _EmailPageState extends State<EmailPage> {
|
|
List emails = [];
|
|
|
|
void _displayEmailsFromFolder(String folder) async {
|
|
// Map<String, List<SerializableMessage>> messagesMap = {};
|
|
List<SerializableMessage> allEmails = [];
|
|
|
|
try {
|
|
var url = Uri.http(
|
|
'127.0.0.1:3001', 'sorted_threads_by_date', {'folder': folder});
|
|
var response = await http.get(url);
|
|
// print(response.body);
|
|
// Map<String, dynamic> json = jsonDecode(response.body); original
|
|
|
|
// json.forEach((key, value) {
|
|
// List<SerializableMessage> messages = (value as List)
|
|
// .map((item) => SerializableMessage.fromJson(item))
|
|
// .toList();
|
|
// messagesMap[key] = messages;
|
|
// });
|
|
|
|
// new shit
|
|
if (response.statusCode == 200) {
|
|
List<dynamic> json = jsonDecode(response.body);
|
|
for (var item in json) {
|
|
if (item.length > 1 && item[0] is String && item[1] is List) {
|
|
// print('Date: ${item[0]}, Threads: ${item[1]}');
|
|
List<int> threadIDs = List<int>.from(item[1]);
|
|
for (var threadId in threadIDs) {
|
|
await fetchThreadMessages(threadId, allEmails);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
throw Exception('Failed to load threads');
|
|
}
|
|
} catch (e) {
|
|
print('_displayEmailsFromFolder caught error: $e');
|
|
}
|
|
setState(() {
|
|
emails.clear();
|
|
// emails = messagesMap.values.toList().expand((list) => list).toList();
|
|
emails.addAll(allEmails);
|
|
// print(emails);
|
|
;
|
|
});
|
|
}
|
|
|
|
Future<void> fetchThreadMessages(
|
|
int threadId, List<SerializableMessage> allEmails) async {
|
|
try {
|
|
var url = Uri.http(
|
|
'127.0.0.1:3001', 'get_thread_messages', {'id': threadId.toString()});
|
|
// print(url);
|
|
var response = await http.get(url);
|
|
// print(response.body);
|
|
if (response.statusCode == 200) {
|
|
List<dynamic> messagesJson = jsonDecode(response.body);
|
|
List<SerializableMessage> messages =
|
|
messagesJson.map((mj) => SerializableMessage.fromJson(mj)).toList();
|
|
allEmails.addAll(messages);
|
|
} else {
|
|
throw Exception(
|
|
'Failed to fetch thread messages for thread ID: $threadId');
|
|
}
|
|
} catch (e) {
|
|
print('Error fetching thread messages: $e');
|
|
}
|
|
}
|
|
|
|
Future<String> _getEmailContent(String id) async {
|
|
String content = r"""
|
|
|
|
""";
|
|
// String restcontent = "";
|
|
try {
|
|
var url = Uri.http('127.0.0.1:3001', 'email', {'id': id});
|
|
// print(url);
|
|
var response = await http.get(url);
|
|
// print(response.body);
|
|
if (response.statusCode == 200) {
|
|
print('ok');
|
|
content = response.body;
|
|
// try {
|
|
// var restUrl =
|
|
// Uri.http('127.0.0.1:3001', 'get_thread_messages', {'id': id});
|
|
// // print(restUrl);
|
|
// var restresponse = await http.get(restUrl);
|
|
// // print(restresponse.statusCode);
|
|
// if (restresponse.statusCode == 200) {
|
|
// print("ok squared");
|
|
// // restcontent = restresponse.body;
|
|
// }
|
|
// } catch (i) {
|
|
// print('jsoncontent caught error: $i');
|
|
// }
|
|
}
|
|
} catch (e) {
|
|
print('_getEmailContent caught error: $e');
|
|
}
|
|
// print(content);
|
|
// print(restcontent);
|
|
return content;
|
|
}
|
|
|
|
// Future<String> _getThreadMessagesJson(String threadId) async {
|
|
// String jsonResponse = "";
|
|
|
|
// try {
|
|
// var url =
|
|
// Uri.http('127.0.0.1:3001', 'get_thread_messages', {'id': threadId});
|
|
// // print(url);
|
|
// var response = await http.get(url);
|
|
// // print(response.statusCode);
|
|
// // print(response.body);
|
|
// if (response.statusCode == 200) {
|
|
// jsonResponse = response.body; // Here you get the JSON response
|
|
// } else {
|
|
// throw Exception('Failed to load thread messages');
|
|
// }
|
|
// } catch (e) {
|
|
// print('_getThreadMessagesJson caught error: $e');
|
|
// }
|
|
|
|
// return jsonResponse; // Returns the JSON string
|
|
// }
|
|
|
|
Future<List<Widget>> _getDrawerItems() async {
|
|
List<String> drawerItems = [];
|
|
|
|
try {
|
|
var url = Uri.http('127.0.0.1:3001', 'folders');
|
|
var response = await http.get(url);
|
|
drawerItems = List<String>.from(json.decode(response.body));
|
|
} catch (e) {
|
|
print('_getDrawerItems caught error: $e');
|
|
}
|
|
|
|
List<Widget> drawerWidgets = [];
|
|
|
|
for (String item in drawerItems) {
|
|
drawerWidgets.add(
|
|
ListTile(
|
|
leading: Icon(Icons.mail),
|
|
title: Text(item),
|
|
onTap: () {
|
|
_displayEmailsFromFolder(item);
|
|
Navigator.pop(context);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
return drawerWidgets;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
backgroundColor: Theme.of(context).colorScheme.inversePrimary,
|
|
title: Text(widget.title),
|
|
),
|
|
drawer: Drawer(
|
|
child: FutureBuilder<List<Widget>>(
|
|
future:
|
|
_getDrawerItems(), // call the async function to get the future
|
|
builder:
|
|
(BuildContext context, AsyncSnapshot<List<Widget>> snapshot) {
|
|
if (snapshot.connectionState == ConnectionState.waiting) {
|
|
// While data is loading, show a progress indicator
|
|
return Center(child: CircularProgressIndicator());
|
|
} else if (snapshot.hasError) {
|
|
// If something went wrong, show an error message
|
|
return Center(child: Text('Error: ${snapshot.error}'));
|
|
} else {
|
|
// When data is fetched successfully, display the items
|
|
return ListView(
|
|
padding: EdgeInsets.zero,
|
|
children:
|
|
snapshot.data!, // Unwrap the data once confirmed it's there
|
|
);
|
|
}
|
|
},
|
|
),
|
|
),
|
|
body: EmailListScreen(
|
|
emails: emails,
|
|
getEmailContent: _getEmailContent,
|
|
// getJsonEmail: _getThreadMessagesJson
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class EmailListScreen extends StatelessWidget {
|
|
final List emails;
|
|
final Future<String> Function(String) getEmailContent;
|
|
// final Future<String> Function(String) getJsonEmail;
|
|
|
|
EmailListScreen({
|
|
required this.emails,
|
|
required this.getEmailContent,
|
|
// required this.getJsonEmail
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
// print(emails);
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: Text('Emails'),
|
|
),
|
|
body: ListView.separated(
|
|
itemCount: emails.length,
|
|
itemBuilder: (context, index) {
|
|
return ListTile(
|
|
title: Text(emails[index].from,
|
|
style: TextStyle(fontWeight: FontWeight.bold)),
|
|
subtitle: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(emails[index].subject),
|
|
],
|
|
),
|
|
trailing: Text(emails[index].date.toString()),
|
|
onTap: () async {
|
|
String emailContent = await getEmailContent(emails[index].id);
|
|
// String jsonContent =
|
|
// await getJsonEmail(emails[index].uid.toString());
|
|
// print(emails[index]);
|
|
String from = emails[index].from.toString();
|
|
String name = emails[index].name.toString();
|
|
String to = emails[index].to.toString();
|
|
String cc = emails[index].cc.toString();
|
|
String hash = emails[index].hash.toString();
|
|
String subject = emails[index].subject.toString();
|
|
String date = emails[index].date.toString();
|
|
String uid = emails[index].uid.toString();
|
|
String list = emails[index].list.toString();
|
|
String id = emails[index].id.toString();
|
|
String in_reply_to = emails[index].in_reply_to.toString();
|
|
// String jsonbuilt =
|
|
Navigator.push(
|
|
context,
|
|
MaterialPageRoute(
|
|
builder: (context) => EmailView(
|
|
emailContent: emailContent,
|
|
// jsonEmail: jsonContent,
|
|
from: from, name: name, to: to, cc: cc, hash: hash,
|
|
subject: subject, date: date,
|
|
uid: uid, list: list, id: id,
|
|
in_reply_to: in_reply_to,
|
|
)),
|
|
);
|
|
});
|
|
},
|
|
separatorBuilder: (context, index) {
|
|
return Divider();
|
|
},
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class EmailView extends StatefulWidget {
|
|
final String emailContent;
|
|
// final String jsonEmail;
|
|
final String from;
|
|
final String name;
|
|
final String to;
|
|
final String cc;
|
|
final String hash;
|
|
final String subject;
|
|
final String date;
|
|
final String uid;
|
|
final String list;
|
|
final String id;
|
|
final String in_reply_to;
|
|
|
|
const EmailView(
|
|
{Key? key,
|
|
required this.emailContent,
|
|
// required this.jsonEmail,
|
|
required this.from,
|
|
required this.name,
|
|
required this.to,
|
|
required this.cc,
|
|
required this.hash,
|
|
required this.subject,
|
|
required this.date,
|
|
required this.uid,
|
|
required this.list,
|
|
required this.id,
|
|
required this.in_reply_to})
|
|
: super(key: key);
|
|
@override
|
|
_EmailViewState createState() => _EmailViewState();
|
|
}
|
|
|
|
class _EmailViewState extends State<EmailView> {
|
|
late Key iframeKey;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
iframeKey = Key("iframe-${widget.id}");
|
|
ui.platformViewRegistry.registerViewFactory(
|
|
// 'html-view33'
|
|
iframeKey.toString(),
|
|
(int viewId) => html.IFrameElement()
|
|
..width = '100%'
|
|
..height = '100%'
|
|
..srcdoc = widget.emailContent
|
|
..style.border = 'none',
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: Text(widget.name),
|
|
),
|
|
body: HtmlElementView(
|
|
key: iframeKey,
|
|
viewType: iframeKey.toString(),
|
|
// 'html-view33',
|
|
),
|
|
);
|
|
}
|
|
}
|