381 lines
12 KiB
Dart
381 lines
12 KiB
Dart
// this file should handle most of the API calls
|
|
// it also builds some widgets, but it will be modulated later // chat it did
|
|
|
|
import 'dart:async';
|
|
import 'dart:typed_data';
|
|
|
|
import 'structs.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'dart:convert';
|
|
|
|
class ApiService {
|
|
static String ip = "";
|
|
static String port = "";
|
|
static List<AttachmentResponse> threadAttachments =
|
|
[]; //holds attachments of the thread
|
|
static String currFolder = "";
|
|
static List<String> currThread = []; //holds the email ids of the thread
|
|
static String currThreadID = ""; //picked an email it prints the threadID
|
|
|
|
Future<List<GetThreadResponse>> fetchEmailsFromFolder(
|
|
String folder, int pagenitaion) async {
|
|
try {
|
|
var url = Uri.http('$ip:$port', 'sorted_threads_by_date', {
|
|
'folder': folder,
|
|
'limit': '50',
|
|
'offset': pagenitaion.toString(),
|
|
});
|
|
var response = await http.get(url);
|
|
List<GetThreadResponse> allEmails = [];
|
|
|
|
if (response.statusCode == 200) {
|
|
List json = jsonDecode(response.body);
|
|
for (var item in json) {
|
|
//each item in the json is a date
|
|
if (item.length > 1 && item[0] is String && item[1] is List) {
|
|
List<int> threadIDs = List<int>.from(item[1]);
|
|
for (var threadId in threadIDs) {
|
|
await fetchThreads(threadId, allEmails);
|
|
}
|
|
}
|
|
}
|
|
currFolder = folder;
|
|
return allEmails;
|
|
} else {
|
|
throw Exception('Failed to load threads');
|
|
}
|
|
} catch (e) {
|
|
print('_displayEmailsFromFolder caught error: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
Future<void> fetchThreads(
|
|
//populates allEmails, which is the List that contains all the emails in a thread
|
|
int threadId,
|
|
List<GetThreadResponse> allEmails) async {
|
|
try {
|
|
var url = Uri.http('${ApiService.ip}:${ApiService.port}', 'get_thread',
|
|
{'id': threadId.toString()});
|
|
var response = await http.get(url);
|
|
|
|
if (response.statusCode == 200) {
|
|
Map<String, dynamic> messagesJson = jsonDecode(response.body);
|
|
GetThreadResponse threadResponse =
|
|
GetThreadResponse.fromJson(messagesJson);
|
|
|
|
allEmails.add(threadResponse);
|
|
} else {
|
|
throw Exception(
|
|
'Failed to fetch thread messages for thread ID: $threadId');
|
|
}
|
|
} catch (e) {
|
|
print('Error fetching thread messages: $e');
|
|
}
|
|
}
|
|
|
|
Future<List<SerializableMessage>> sonicSearch(
|
|
String list, int limit, int offset, String query) async {
|
|
try {
|
|
var url = Uri.http('$ip:$port', 'search_emails', {
|
|
'list': list,
|
|
'limit': limit.toString(),
|
|
'offset': offset.toString(),
|
|
'query': query
|
|
});
|
|
print(url);
|
|
|
|
var response = await http.get(url);
|
|
print(response);
|
|
if (response.statusCode == 200) {
|
|
List<dynamic> messagesJson = json.decode(response.body);
|
|
List<SerializableMessage> messages =
|
|
messagesJson.map((mj) => SerializableMessage.fromJson(mj)).toList();
|
|
return messages;
|
|
}
|
|
print(response.statusCode);
|
|
} catch (e) {
|
|
print("caught $e");
|
|
}
|
|
return [];
|
|
}
|
|
|
|
//returns the html for the email, it gets used in emailView
|
|
Future<List<String>> fetchEmailContent(
|
|
List<String> IDsString, String emailFolder) async {
|
|
String content = r"""
|
|
""";
|
|
List<String> HTMLofThread = [];
|
|
threadAttachments = [];
|
|
int counter = 0;
|
|
|
|
try {
|
|
//attaches email after email from a thread
|
|
for (var id in IDsString) {
|
|
var url = Uri.http('$ip:$port', 'email', {'id': id});
|
|
var response = await http.get(url);
|
|
currThread.add(id);
|
|
if (response.statusCode == 200) {
|
|
counter += 1;
|
|
content += response.body;
|
|
HTMLofThread.add(response.body);
|
|
try {
|
|
List<AttachmentInfo> attachments =
|
|
await getAttachmentsInfo(emailFolder, id);
|
|
for (var attachment in attachments) {
|
|
//TODO: for each attachment creaate at the bottom a widget for each individual one
|
|
threadAttachments
|
|
.add(await getAttachment(emailFolder, id, attachment.name));
|
|
}
|
|
} catch (innerError) {
|
|
print('_getAttachment info caught error $innerError');
|
|
}
|
|
content +=
|
|
"""<div id="JuanBedarramarker" style="width: 10px; height: 30px;"></div>""";
|
|
content += "<hr><p>end of email</p>";
|
|
}
|
|
}
|
|
} catch (e) {
|
|
print('_getEmailContent caught error: $e');
|
|
}
|
|
return HTMLofThread;
|
|
}
|
|
|
|
Future<List<SerializableMessage>> threadsInSerializable(
|
|
String thread_id) async {
|
|
//actually a xyzwtv@gmail.com
|
|
// grab all of the emails in thread anyways, for the future it'll come in handy // maybe not
|
|
var url = Uri.http('$ip:$port', 'get_thread_messages', {'id': thread_id});
|
|
try {
|
|
var response = await http.get(url);
|
|
if (response.statusCode == 200) {
|
|
List json = jsonDecode(response.body);
|
|
List<SerializableMessage> serializableMessages = [];
|
|
for (var mail in json) {
|
|
serializableMessages.add(SerializableMessage.fromJson(mail));
|
|
}
|
|
return serializableMessages;
|
|
} else {
|
|
print(
|
|
"failed get request with status code ${response.statusCode}, and body ${response.body}");
|
|
}
|
|
} catch (e) {
|
|
print("caught in threadInSerializable method error: $e");
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
Future<bool> moveEmail(
|
|
//only moves the first email of the thread //or perhaps should do the last
|
|
String fromFolder,
|
|
String thread_id,
|
|
String toFolder) async {
|
|
var url = Uri.http('$ip:$port', 'move_email');
|
|
|
|
List<SerializableMessage> mailsInSerializable =
|
|
await this.threadsInSerializable(thread_id);
|
|
|
|
if (mailsInSerializable.isEmpty) {
|
|
return false;
|
|
}
|
|
|
|
SerializableMessage firstMail = mailsInSerializable[0];
|
|
|
|
Map<String, String> requestBody = {
|
|
'from': fromFolder,
|
|
'uid': firstMail.uid.toString(),
|
|
'to': toFolder,
|
|
};
|
|
|
|
try {
|
|
var response = await http.post(
|
|
url,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: jsonEncode(requestBody),
|
|
);
|
|
if (response.statusCode == 200) {
|
|
print('response body ${response.body}');
|
|
return true;
|
|
} else {
|
|
print('error ${response.statusCode} ${response.body}');
|
|
}
|
|
} catch (e) {
|
|
print("failed trying to post move_email, with error: $e");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Future<List<String>> fetchFolders() async {
|
|
try {
|
|
var url = Uri.http('$ip:$port', 'folders');
|
|
var response = await http.get(url);
|
|
return List<String>.from(json.decode(response.body));
|
|
} catch (e) {
|
|
print('fetchFolders caught error: $e');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
Future<void> createFolder(String folderName) async {
|
|
var url = Uri.http('$ip:$port', 'create_folder');
|
|
|
|
Map<String, String> requestBody = {'name': folderName};
|
|
|
|
try {
|
|
var response = await http.post(
|
|
url,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: jsonEncode(requestBody),
|
|
);
|
|
if (response.statusCode == 200) {
|
|
print('response body: ${response.body}');
|
|
} else {
|
|
print('Error: ${response.statusCode}, response body: ${response.body}');
|
|
}
|
|
} catch (e) {
|
|
print('error making post req: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> renameFolder(String oldFolder, String newFolder) async {
|
|
var url = Uri.http('$ip:$port', 'rename_folder');
|
|
Map<String, String> requestBody = {
|
|
'old_name': oldFolder,
|
|
'new_name': newFolder,
|
|
};
|
|
|
|
try {
|
|
var response = await http.post(
|
|
url,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: jsonEncode(requestBody),
|
|
);
|
|
if (response.statusCode == 200) {
|
|
print('response body: ${response.body}');
|
|
} else {
|
|
print('Error: ${response.statusCode}, response body: ${response.body}');
|
|
}
|
|
} catch (e) {
|
|
print('error making post req: $e');
|
|
}
|
|
}
|
|
|
|
Future<void> deleteFolder(String folderName) async {
|
|
var url = Uri.http('$ip:$port', 'delete_folder');
|
|
|
|
Map<String, String> requestBody = {'name': folderName};
|
|
|
|
try {
|
|
var response = await http.post(
|
|
url,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: jsonEncode(requestBody),
|
|
);
|
|
if (response.statusCode == 200) {
|
|
print('response body: ${response.body}');
|
|
} else {
|
|
print('Error: ${response.statusCode}, response body: ${response.body}');
|
|
}
|
|
} catch (e) {
|
|
print('error making post req: $e');
|
|
}
|
|
}
|
|
|
|
Future<bool> logIn(String json) async {
|
|
return false;
|
|
}
|
|
|
|
Future<List<AttachmentInfo>> getAttachmentsInfo(
|
|
String folder, String email_id) async {
|
|
try {
|
|
var url = Uri.http('$ip:$port', 'get_attachments_info',
|
|
{'folder': folder, 'id': email_id});
|
|
// print(url);
|
|
var response = await http.get(url);
|
|
// print("response $response");
|
|
if (response.statusCode == 200) {
|
|
var result = response.body;
|
|
// print(result);
|
|
List<dynamic> attachmentList = json.decode(result);
|
|
// Map<String, dynamic> attachmentList = json.decode(result);
|
|
|
|
// print("attachment list $attachmentList");
|
|
List<AttachmentInfo> attachments =
|
|
attachmentList.map((al) => AttachmentInfo.fromJson(al)).toList();
|
|
// print("attachments $attachments");
|
|
|
|
return attachments;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
}
|
|
return [];
|
|
}
|
|
|
|
Future<AttachmentResponse> getAttachment(
|
|
String folder, String email_id, String name) async {
|
|
try {
|
|
var url = Uri.http('$ip:$port', 'get_attachment',
|
|
{'folder': folder, 'id': email_id, 'name': name});
|
|
var response = await http.get(url);
|
|
if (response.statusCode == 200) {
|
|
var result = response.body;
|
|
Map<String, dynamic> attachmentData = json.decode(result);
|
|
AttachmentResponse data = AttachmentResponse.fromJson(attachmentData);
|
|
print("data $data");
|
|
return data;
|
|
}
|
|
} catch (e) {
|
|
print("getAttachment failed $e");
|
|
}
|
|
return AttachmentResponse(name: "error", data: Uint8List(0));
|
|
}
|
|
|
|
Future<List<String>> fetchMarkdownContent(
|
|
List<String> IDsString, String emailFolder) async {
|
|
List<String> MDofThread = [];
|
|
threadAttachments = [];
|
|
int counter = 0;
|
|
|
|
try {
|
|
//attaches email after email from a thread
|
|
for (var id in IDsString) {
|
|
var url = Uri.http('$ip:$port', 'email_md', {'id': id});
|
|
print(url);
|
|
var response = await http.get(url);
|
|
currThread.add(id);
|
|
if (response.statusCode == 200) {
|
|
counter += 1;
|
|
Map<String, dynamic> json = jsonDecode(response.body);
|
|
|
|
MDofThread.add(json['md'] ?? '');
|
|
try {
|
|
List<AttachmentInfo> attachments =
|
|
await getAttachmentsInfo(emailFolder, id);
|
|
for (var attachment in attachments) {
|
|
//TODO: for each attachment creaate at the bottom a widget for each individual one
|
|
threadAttachments
|
|
.add(await getAttachment(emailFolder, id, attachment.name));
|
|
}
|
|
} catch (innerError) {
|
|
print('_getAttachment info caught error $innerError');
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
print('_getMDContent caught error: $e');
|
|
}
|
|
|
|
return MDofThread;
|
|
}
|
|
}
|