mirror of
https://gitlab.com/comunic/comunicmobile
synced 2024-12-27 05:18:50 +00:00
425 lines
14 KiB
Dart
425 lines
14 KiB
Dart
import 'package:comunic/helpers/database/conversation_messages_database_helper.dart';
|
|
import 'package:comunic/helpers/database/conversations_database_helper.dart';
|
|
import 'package:comunic/helpers/users_helper.dart';
|
|
import 'package:comunic/helpers/websocket_helper.dart';
|
|
import 'package:comunic/lists/conversation_messages_list.dart';
|
|
import 'package:comunic/lists/conversations_list.dart';
|
|
import 'package:comunic/lists/users_list.dart';
|
|
import 'package:comunic/models/api_request.dart';
|
|
import 'package:comunic/models/api_response.dart';
|
|
import 'package:comunic/models/conversation.dart';
|
|
import 'package:comunic/models/conversation_message.dart';
|
|
import 'package:comunic/models/displayed_content.dart';
|
|
import 'package:comunic/models/new_conversation_message.dart';
|
|
import 'package:comunic/utils/account_utils.dart';
|
|
import 'package:meta/meta.dart';
|
|
|
|
/// Conversation helper
|
|
///
|
|
/// @author Pierre HUBERT
|
|
|
|
enum SendMessageResult { SUCCESS, MESSAGE_REJECTED, FAILED }
|
|
|
|
class ConversationsHelper {
|
|
static final _registeredConversations = Map<int, int>();
|
|
|
|
final ConversationsDatabaseHelper _conversationsDatabaseHelper =
|
|
ConversationsDatabaseHelper();
|
|
final ConversationMessagesDatabaseHelper _conversationMessagesDatabaseHelper =
|
|
ConversationMessagesDatabaseHelper();
|
|
|
|
/// Create a new conversation
|
|
///
|
|
/// Return the ID of the newly created conversation or -1 in case of failure
|
|
Future<int> createConversation(Conversation settings) async {
|
|
final response =
|
|
await APIRequest(uri: "conversations/create", needLogin: true, args: {
|
|
"name": settings.hasName ? settings.name : "false",
|
|
"follow": settings.following ? "true" : "false",
|
|
"users": settings.members.join(","),
|
|
}).addBool("canEveryoneAddMembers", settings.canEveryoneAddMembers).exec();
|
|
|
|
if (response.code != 200) return -1;
|
|
|
|
return response.getObject()["conversationID"];
|
|
}
|
|
|
|
/// Update an existing conversation
|
|
///
|
|
/// Returns a boolean depending of the success of the operation
|
|
Future<bool> updateConversation(Conversation settings) async {
|
|
final request =
|
|
APIRequest(uri: "conversations/updateSettings", needLogin: true, args: {
|
|
"conversationID": settings.id.toString(),
|
|
"following": settings.following ? "true" : "false"
|
|
});
|
|
|
|
if (settings.isOwner || settings.canEveryoneAddMembers)
|
|
request.addString("members", settings.members.join(","));
|
|
|
|
// Update all conversation settings, if possible
|
|
if (settings.isOwner) {
|
|
request.addString("name", settings.hasName ? settings.name : "false");
|
|
request.addBool("canEveryoneAddMembers", settings.canEveryoneAddMembers);
|
|
}
|
|
|
|
final response = await request.exec();
|
|
|
|
if (response.code != 200) return false;
|
|
|
|
//Delete old conversation entry from the database
|
|
await _conversationsDatabaseHelper.delete(settings.id);
|
|
|
|
// Success
|
|
return true;
|
|
}
|
|
|
|
/// Delete a conversation specified by its [id]
|
|
Future<bool> deleteConversation(int id) async {
|
|
final response = await APIRequest(
|
|
uri: "conversations/delete",
|
|
needLogin: true,
|
|
args: {
|
|
"conversationID": id.toString(),
|
|
},
|
|
).exec();
|
|
|
|
return response.code == 200;
|
|
}
|
|
|
|
/// Download the list of conversations from the server
|
|
Future<ConversationsList> downloadList() async {
|
|
final response =
|
|
await APIRequest(uri: "conversations/getList", needLogin: true).exec();
|
|
|
|
if (response.code != 200) return null;
|
|
|
|
try {
|
|
ConversationsList list = ConversationsList();
|
|
response.getArray().forEach((f) => list.add(apiToConversation(f)));
|
|
|
|
// Update the database
|
|
await _conversationsDatabaseHelper.clearTable();
|
|
await _conversationsDatabaseHelper.insertAll(list);
|
|
|
|
return list;
|
|
} on Exception catch (e) {
|
|
print(e.toString());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// Get the local list of conversations
|
|
Future<ConversationsList> getCachedList() async {
|
|
final list = await _conversationsDatabaseHelper.getAll();
|
|
list.sort();
|
|
return list;
|
|
}
|
|
|
|
/// Get information about a single conversation specified by its [id]
|
|
Future<Conversation> _downloadSingle(int id) async {
|
|
try {
|
|
final response = await APIRequest(
|
|
uri: "conversations/getInfoOne",
|
|
needLogin: true,
|
|
args: {"conversationID": id.toString()}).exec();
|
|
|
|
if (response.code != 200) return null;
|
|
|
|
final conversation = apiToConversation(response.getObject());
|
|
_conversationsDatabaseHelper.insertOrUpdate(conversation);
|
|
return conversation;
|
|
} on Exception catch (e) {
|
|
print(e.toString());
|
|
print("Could not get information about a single conversation !");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// Get information about a single conversation. If [force] is set to false,
|
|
/// cached version of the conversation will be used, else it will always get
|
|
/// the information from the server
|
|
Future<Conversation> getSingle(int id, {bool force = false}) async {
|
|
if (force || !await _conversationsDatabaseHelper.has(id))
|
|
return await _downloadSingle(id);
|
|
else
|
|
return _conversationsDatabaseHelper.get(id);
|
|
}
|
|
|
|
/// Get information about a conversation. The method throws an [Exception] in
|
|
/// case of failure
|
|
///
|
|
/// Return value of this method is never null.
|
|
Future<Conversation> getSingleOrThrow(int id, {bool force = false}) async {
|
|
final conv = await this.getSingle(id, force: force);
|
|
|
|
if (conv == null)
|
|
throw Exception("Could not get information about the conversation!");
|
|
|
|
return conv;
|
|
}
|
|
|
|
/// Get the name of a [conversation]. This requires information
|
|
/// about the users of this conversation
|
|
static String getConversationName(
|
|
Conversation conversation, UsersList users) {
|
|
if (conversation.hasName) return conversation.name;
|
|
|
|
String name = "";
|
|
int count = 0;
|
|
for (int i = 0; i < 3 && i < conversation.members.length; i++)
|
|
if (conversation.members[i] != userID()) {
|
|
name += (count > 0 ? ", " : "") +
|
|
users.getUser(conversation.members[i]).fullName;
|
|
count++;
|
|
}
|
|
|
|
if (conversation.members.length > 3) name += ", ...";
|
|
|
|
return name;
|
|
}
|
|
|
|
/// Search and return a private conversation with a given [userID]. If such
|
|
/// conversation does not exists, it is created if [allowCreate] is set to
|
|
/// true
|
|
Future<int> getPrivate(int userID, {bool allowCreate = true}) async {
|
|
final response = await APIRequest(
|
|
uri: "conversations/getPrivate",
|
|
needLogin: true,
|
|
args: {
|
|
"otherUser": userID.toString(),
|
|
"allowCreate": allowCreate.toString()
|
|
},
|
|
).exec();
|
|
|
|
if (response.code != 200) return null;
|
|
|
|
// Get and return conversation ID
|
|
try {
|
|
return int.parse(response.getObject()["conversationsID"][0].toString());
|
|
} catch (e) {
|
|
e.toString();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// Asynchronously get the name of the conversation
|
|
///
|
|
/// Unlike the synchronous method, this method does not need information
|
|
/// about the members of the conversation
|
|
///
|
|
/// Returns null in case of failure
|
|
static Future<String> getConversationNameAsync(
|
|
Conversation conversation) async {
|
|
if (conversation.hasName) return conversation.name;
|
|
|
|
//Get information about the members of the conversation
|
|
final members = await UsersHelper().getUsersInfo(conversation.members);
|
|
|
|
if (members == null) return null;
|
|
|
|
return ConversationsHelper.getConversationName(conversation, members);
|
|
}
|
|
|
|
/// Turn an API entry into a [Conversation] object
|
|
static Conversation apiToConversation(Map<String, dynamic> map) {
|
|
return Conversation(
|
|
id: map["ID"],
|
|
ownerID: map["ID_owner"],
|
|
lastActive: map["last_active"],
|
|
name: map["name"] == false ? null : map["name"],
|
|
following: map["following"] == 1,
|
|
sawLastMessage: map["saw_last_message"] == 1,
|
|
members: List<int>.from(map["members"]),
|
|
canEveryoneAddMembers: map["canEveryoneAddMembers"],
|
|
callCapabilities: map["can_have_video_call"]
|
|
? CallCapabilities.VIDEO
|
|
: (map["can_have_call"]
|
|
? CallCapabilities.AUDIO
|
|
: CallCapabilities.NONE),
|
|
isHavingCall: map["has_call_now"]);
|
|
}
|
|
|
|
/// Parse a list of messages given by the server
|
|
Future<ConversationMessagesList> _parseConversationMessageFromServer(
|
|
int conversationID, APIResponse response) async {
|
|
if (response.code != 200) return null;
|
|
|
|
// Parse the response of the server
|
|
ConversationMessagesList list = ConversationMessagesList();
|
|
response.getArray().forEach((f) {
|
|
list.add(
|
|
apiToConversationMessage(f),
|
|
);
|
|
});
|
|
|
|
// Save messages in the cache
|
|
_conversationMessagesDatabaseHelper.insertOrUpdateAll(list);
|
|
|
|
return list;
|
|
}
|
|
|
|
/// Refresh the list of messages of a conversation
|
|
///
|
|
/// Set [lastMessageID] to 0 to specify that we do not have any message of the
|
|
/// conversation yet or another value else
|
|
Future<ConversationMessagesList> _downloadNewMessagesSingle(
|
|
int conversationID,
|
|
{int lastMessageID = 0}) async {
|
|
// Execute the request on the server
|
|
final response = await APIRequest(
|
|
uri: "conversations/refresh_single",
|
|
needLogin: true,
|
|
args: {
|
|
"conversationID": conversationID.toString(),
|
|
"last_message_id": lastMessageID.toString()
|
|
}).exec();
|
|
|
|
return await _parseConversationMessageFromServer(conversationID, response);
|
|
}
|
|
|
|
/// Get older messages for a given conversation from an online source
|
|
Future<ConversationMessagesList> getOlderMessages({
|
|
@required int conversationID,
|
|
@required int oldestMessagesID,
|
|
int limit = 15,
|
|
}) async {
|
|
// Perform the request online
|
|
final response = await APIRequest(
|
|
uri: "conversations/get_older_messages",
|
|
needLogin: true,
|
|
args: {
|
|
"conversationID": conversationID.toString(),
|
|
"oldest_message_id": oldestMessagesID.toString(),
|
|
"limit": limit.toString()
|
|
}).exec();
|
|
|
|
return await _parseConversationMessageFromServer(conversationID, response);
|
|
}
|
|
|
|
/// Get new messages for a given conversation
|
|
///
|
|
/// If [lastMessageID] is set to 0 then we retrieve the last messages of
|
|
/// the conversation.
|
|
/// Otherwise [lastMessageID] contains the ID of the last known message
|
|
Future<ConversationMessagesList> getNewMessages(
|
|
{@required int conversationID,
|
|
int lastMessageID = 0,
|
|
bool online = true}) async {
|
|
if (online)
|
|
return await _downloadNewMessagesSingle(conversationID,
|
|
lastMessageID: lastMessageID);
|
|
else
|
|
return await _conversationMessagesDatabaseHelper
|
|
.getAllMessagesConversations(conversationID,
|
|
lastMessageID: lastMessageID);
|
|
}
|
|
|
|
/// Get a single conversation message from the local database
|
|
///
|
|
/// Returns the message if found or null in case of failure
|
|
Future<ConversationMessage> getSingleMessageFromCache(int messageID) async {
|
|
return await _conversationMessagesDatabaseHelper.get(messageID);
|
|
}
|
|
|
|
/// Send a new message to the server
|
|
Future<SendMessageResult> sendMessage(NewConversationMessage message) async {
|
|
final request = APIRequest(
|
|
uri: "conversations/sendMessage",
|
|
needLogin: true,
|
|
args: {
|
|
"conversationID": message.conversationID.toString(),
|
|
"message": message.hasMessage ? message.message : ""
|
|
},
|
|
);
|
|
|
|
//Check for image
|
|
if (message.hasImage) request.addFile("image", message.image);
|
|
|
|
//Send the message
|
|
APIResponse response;
|
|
if (!message.hasImage)
|
|
response = await request.exec();
|
|
else
|
|
response = await request.execWithFiles();
|
|
|
|
if (response.code == 401)
|
|
return SendMessageResult.MESSAGE_REJECTED;
|
|
else if (response.code != 200) return SendMessageResult.FAILED;
|
|
|
|
return SendMessageResult.SUCCESS;
|
|
}
|
|
|
|
/// Save / Update a message into the database
|
|
Future<void> saveMessage(ConversationMessage msg) async {
|
|
await _conversationMessagesDatabaseHelper.insertOrUpdate(msg);
|
|
}
|
|
|
|
/// Remove a message from the database
|
|
Future<void> removeMessage(int msgID) async {
|
|
await _conversationMessagesDatabaseHelper.delete(msgID);
|
|
}
|
|
|
|
/// Update a message content
|
|
Future<bool> updateMessage(int id, String newContent) async {
|
|
final response = await APIRequest(
|
|
uri: "conversations/updateMessage",
|
|
needLogin: true,
|
|
args: {"messageID": id.toString(), "content": newContent}).exec();
|
|
|
|
if (response.code != 200) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Delete permanently a message specified by its [id]
|
|
Future<bool> deleteMessage(int id) async {
|
|
// Delete the message online
|
|
final response = await APIRequest(
|
|
uri: "conversations/deleteMessage",
|
|
needLogin: true,
|
|
args: {"messageID": id.toString()}).exec();
|
|
|
|
if (response.code != 200) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Register a conversation : ask the server to notify about updates to the
|
|
/// conversation through WebSocket
|
|
Future<void> registerConversationEvents(int id) async {
|
|
if (_registeredConversations.containsKey(id))
|
|
_registeredConversations[id]++;
|
|
else {
|
|
_registeredConversations[id] = 1;
|
|
await ws("\$main/register_conv", {"convID": id});
|
|
}
|
|
}
|
|
|
|
/// Un-register to conversation update events
|
|
Future<void> unregisterConversationEvents(int id) async {
|
|
if (!_registeredConversations.containsKey(id)) return;
|
|
|
|
_registeredConversations[id]--;
|
|
|
|
if (_registeredConversations[id] <= 0) {
|
|
_registeredConversations.remove(id);
|
|
await ws("\$main/unregister_conv", {"convID": id});
|
|
}
|
|
}
|
|
|
|
/// Turn an API response into a ConversationMessage object
|
|
static ConversationMessage apiToConversationMessage(
|
|
Map<String, dynamic> map,
|
|
) {
|
|
return ConversationMessage(
|
|
id: map["ID"],
|
|
conversationID: map["convID"],
|
|
userID: map["ID_user"],
|
|
timeInsert: map["time_insert"],
|
|
message: DisplayedString(map["message"]),
|
|
imageURL: map["image_path"],
|
|
);
|
|
}
|
|
}
|