|
|
/*! |
|
|
* Webogram v0.5.4 - messaging web application for MTProto |
|
|
* https://github.com/zhukov/webogram |
|
|
* Copyright (C) 2014 Igor Zhukov <igor.beatle@gmail.com> |
|
|
* https://github.com/zhukov/webogram/blob/master/LICENSE |
|
|
*/ |
|
|
|
|
|
'use strict'; |
|
|
|
|
|
angular.module('myApp.services') |
|
|
|
|
|
.service('AppMessagesManager', function ($q, $rootScope, $location, $filter, $timeout, $sce, ApiUpdatesManager, AppUsersManager, AppChatsManager, AppPeersManager, AppPhotosManager, AppDocsManager, AppStickersManager, AppMessagesIDsManager, DraftsManager, AppWebPagesManager, MtpApiManager, MtpApiFileManager, ServerTimeManager, RichTextProcessor, NotificationsManager, Storage, AppProfileManager, TelegramMeWebService, ErrorService, StatusManager, _) { |
|
|
|
|
|
var messagesStorage = {}; |
|
|
var messagesForHistory = {}; |
|
|
var messagesForDialogs = {}; |
|
|
var historiesStorage = {}; |
|
|
var dialogsStorage = {count: null, dialogs: []}; |
|
|
var pendingByRandomID = {}; |
|
|
var pendingByMessageID = {}; |
|
|
var pendingAfterMsgs = {}; |
|
|
var sendFilePromise = $q.when(); |
|
|
var tempID = -1; |
|
|
|
|
|
var dialogsIndex = SearchIndexManager.createIndex(), |
|
|
cachedResults = {query: false}; |
|
|
|
|
|
var lastSearchFilter = {}, |
|
|
lastSearchResults = []; |
|
|
|
|
|
var needSingleMessages = [], |
|
|
fetchSingleMessagesTimeout = false; |
|
|
|
|
|
var incrementedMessageViews = {}, |
|
|
needIncrementMessageViews = [], |
|
|
incrementMessageViewsTimeout = false; |
|
|
|
|
|
var maxSeenID = false; |
|
|
if (Config.Modes.packed) { |
|
|
Storage.get('max_seen_msg').then(function (maxID) { |
|
|
maxSeenID = maxID || 0; |
|
|
}); |
|
|
} |
|
|
|
|
|
|
|
|
var dateOrTimeFilter = $filter('dateOrTime'); |
|
|
var fwdMessagesPluralize = _.pluralize('conversation_forwarded_X_messages'); |
|
|
|
|
|
NotificationsManager.start(); |
|
|
|
|
|
var allDialogsLoaded = false |
|
|
var dialogsOffsetDate = 0; |
|
|
var dialogsNum = 0; |
|
|
|
|
|
var migratedFromTo = {}; |
|
|
var migratedToFrom = {}; |
|
|
|
|
|
function getConversations (query, offsetIndex, limit) { |
|
|
var curDialogStorage = dialogsStorage; |
|
|
var isSearch = angular.isString(query) && query.length; |
|
|
|
|
|
if (isSearch) { |
|
|
if (!limit || cachedResults.query !== query) { |
|
|
cachedResults.query = query; |
|
|
|
|
|
var results = SearchIndexManager.search(query, dialogsIndex); |
|
|
|
|
|
cachedResults.dialogs = []; |
|
|
angular.forEach(dialogsStorage.dialogs, function (dialog) { |
|
|
if (results[dialog.peerID]) { |
|
|
cachedResults.dialogs.push(dialog); |
|
|
} |
|
|
}); |
|
|
cachedResults.count = cachedResults.dialogs.length; |
|
|
} |
|
|
curDialogStorage = cachedResults; |
|
|
} else { |
|
|
cachedResults.query = false; |
|
|
} |
|
|
|
|
|
var offset = 0; |
|
|
if (offsetIndex > 0) { |
|
|
for (offset = 0; offset < curDialogStorage.dialogs.length; offset++) { |
|
|
if (offsetIndex > curDialogStorage.dialogs[offset].index) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
limit = limit || 20; |
|
|
|
|
|
if ( |
|
|
isSearch || |
|
|
allDialogsLoaded || |
|
|
curDialogStorage.dialogs.length >= offset + limit |
|
|
) { |
|
|
return $q.when({ |
|
|
dialogs: curDialogStorage.dialogs.slice(offset, offset + limit) |
|
|
}); |
|
|
} |
|
|
|
|
|
return getTopMessages(limit).then(function () { |
|
|
offset = 0; |
|
|
if (offsetIndex > 0) { |
|
|
for (offset = 0; offset < curDialogStorage.dialogs.length; offset++) { |
|
|
if (offsetIndex > curDialogStorage.dialogs[offset].index) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
return { |
|
|
dialogs: curDialogStorage.dialogs.slice(offset, offset + limit) |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
function getDialogByPeerID (peerID) { |
|
|
for (var i = 0; i < dialogsStorage.dialogs.length; i++) { |
|
|
if (dialogsStorage.dialogs[i].peerID == peerID) { |
|
|
return [dialogsStorage.dialogs[i], i]; |
|
|
} |
|
|
} |
|
|
|
|
|
return []; |
|
|
} |
|
|
|
|
|
function saveConversation (dialog) { |
|
|
var peerID = AppPeersManager.getPeerID(dialog.peer); |
|
|
if (!peerID) { |
|
|
return false; |
|
|
} |
|
|
var channelID = AppPeersManager.isChannel(peerID) ? -peerID : 0; |
|
|
var peerText = AppPeersManager.getPeerSearchText(peerID); |
|
|
SearchIndexManager.indexObject(peerID, peerText, dialogsIndex); |
|
|
|
|
|
var isMegagroup = AppPeersManager.isMegagroup(channelID); |
|
|
var mid = AppMessagesIDsManager.getFullMessageID(dialog.top_message, channelID); |
|
|
var message = getMessage(mid); |
|
|
var offsetDate = message.date; |
|
|
|
|
|
if (!channelID && peerID < 0) { |
|
|
var chat = AppChatsManager.getChat(-peerID); |
|
|
if (chat && chat.migrated_to && chat.pFlags.deactivated) { |
|
|
var migratedToPeer = AppPeersManager.getPeerID(chat.migrated_to); |
|
|
migratedFromTo[peerID] = migratedToPeer; |
|
|
migratedToFrom[migratedToPeer] = peerID; |
|
|
return; |
|
|
} |
|
|
} |
|
|
|
|
|
dialog.top_message = mid; |
|
|
dialog.read_inbox_max_id = AppMessagesIDsManager.getFullMessageID(dialog.read_inbox_max_id, channelID); |
|
|
dialog.read_outbox_max_id = AppMessagesIDsManager.getFullMessageID(dialog.read_outbox_max_id, channelID); |
|
|
|
|
|
var topDate = message.date; |
|
|
if (channelID) { |
|
|
var channel = AppChatsManager.getChat(channelID); |
|
|
if (!topDate || channel.date && channel.date > topDate) { |
|
|
topDate = channel.date; |
|
|
} |
|
|
} |
|
|
var savedDraft = DraftsManager.saveDraft(peerID, dialog.draft); |
|
|
if (savedDraft && savedDraft.date > topDate) { |
|
|
topDate = savedDraft.date; |
|
|
} |
|
|
|
|
|
dialog.index = generateDialogIndex(topDate); |
|
|
dialog.peerID = peerID; |
|
|
|
|
|
pushDialogToStorage(dialog, offsetDate); |
|
|
|
|
|
// Because we saved message without dialog present |
|
|
var unreadKey = message.pFlags.out ? 'read_outbox_max_id' : 'read_inbox_max_id'; |
|
|
if (message.mid && message.mid > dialog[unreadKey]) { |
|
|
message.pFlags.unread = true; |
|
|
} |
|
|
|
|
|
if (historiesStorage[peerID] === undefined && |
|
|
!message.deleted) { |
|
|
var historyStorage = {count: null, history: [mid], pending: []}; |
|
|
historiesStorage[peerID] = historyStorage; |
|
|
if (mergeReplyKeyboard(historyStorage, message)) { |
|
|
$rootScope.$broadcast('history_reply_markup', {peerID: peerID}); |
|
|
} |
|
|
} |
|
|
|
|
|
NotificationsManager.savePeerSettings(peerID, dialog.notify_settings); |
|
|
|
|
|
if (channelID && dialog.pts) { |
|
|
ApiUpdatesManager.addChannelState(channelID, dialog.pts); |
|
|
} |
|
|
|
|
|
if ( |
|
|
!channelID && |
|
|
dialog.unread_count > 0 && |
|
|
maxSeenID && |
|
|
dialog.top_message > maxSeenID |
|
|
) { |
|
|
var notifyPeer = message.flags & 16 ? message.from_id : peerID; |
|
|
if (message.pFlags.unread && |
|
|
!message.pFlags.out && |
|
|
!message.pFlags.silent) { |
|
|
NotificationsManager.getPeerMuted(notifyPeer).then(function (muted) { |
|
|
if (!muted) { |
|
|
notifyAboutMessage(message); |
|
|
} |
|
|
}); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function getTopMessages (limit) { |
|
|
var first = true; |
|
|
var dialogs = dialogsStorage.dialogs; |
|
|
var offsetDate = 0; |
|
|
var offsetID = 0; |
|
|
var offsetPeerID = 0; |
|
|
if (dialogsOffsetDate) { |
|
|
offsetDate = dialogsOffsetDate + ServerTimeManager.serverTimeOffset; |
|
|
} |
|
|
return MtpApiManager.invokeApi('messages.getDialogs', { |
|
|
offset_date: offsetDate, |
|
|
offset_id: AppMessagesIDsManager.getMessageLocalID(offsetID), |
|
|
offset_peer: AppPeersManager.getInputPeerByID(offsetPeerID), |
|
|
limit: limit |
|
|
}, { |
|
|
timeout: 300 |
|
|
}).then(function (dialogsResult) { |
|
|
if (!offsetDate) { |
|
|
TelegramMeWebService.setAuthorized(true); |
|
|
} |
|
|
|
|
|
AppUsersManager.saveApiUsers(dialogsResult.users); |
|
|
AppChatsManager.saveApiChats(dialogsResult.chats); |
|
|
saveMessages(dialogsResult.messages); |
|
|
|
|
|
var maxSeenIdIncremented = offsetDate ? true : false; |
|
|
angular.forEach(dialogsResult.dialogs, function (dialog) { |
|
|
saveConversation(dialog); |
|
|
|
|
|
if (!maxSeenIdIncremented && |
|
|
!AppPeersManager.isChannel(AppPeersManager.getPeerID(dialog.peer))) { |
|
|
incrementMaxSeenID(dialog.top_message); |
|
|
maxSeenIdIncremented = true; |
|
|
} |
|
|
}); |
|
|
|
|
|
if (!dialogsResult.dialogs.length || |
|
|
!dialogsResult.count || |
|
|
dialogs.length >= dialogsResult.count) { |
|
|
allDialogsLoaded = true; |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
function generateDialogIndex (date) { |
|
|
if (date === undefined) { |
|
|
date = tsNow(true) + ServerTimeManager.serverTimeOffset; |
|
|
} |
|
|
return (date * 0x10000) + ((++dialogsNum) & 0xFFFF); |
|
|
} |
|
|
|
|
|
function pushDialogToStorage (dialog, offsetDate) { |
|
|
if (offsetDate && (!dialogsOffsetDate || offsetDate < dialogsOffsetDate)) { |
|
|
dialogsOffsetDate = offsetDate; |
|
|
} |
|
|
var dialogs = dialogsStorage.dialogs; |
|
|
var pos = getDialogByPeerID(dialog.peerID)[1]; |
|
|
if (pos !== undefined) { |
|
|
dialogs.splice(pos, 1); |
|
|
} |
|
|
|
|
|
var index = dialog.index; |
|
|
var i, len = dialogs.length; |
|
|
if (!len || index < dialogs[len - 1].index) { |
|
|
dialogs.push(dialog); |
|
|
} |
|
|
else if (index >= dialogs[0].index) { |
|
|
dialogs.unshift(dialog); |
|
|
} |
|
|
else { |
|
|
for (i = 0; i < len; i++) { |
|
|
if (index > dialogs[i].index) { |
|
|
dialogs.splice(i, 0, dialog); |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function requestHistory (peerID, maxID, limit, offset) { |
|
|
var isChannel = AppPeersManager.isChannel(peerID); |
|
|
var isMegagroup = isChannel && AppPeersManager.isMegagroup(peerID); |
|
|
|
|
|
return MtpApiManager.invokeApi('messages.getHistory', { |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
offset_id: maxID ? AppMessagesIDsManager.getMessageLocalID(maxID) : 0, |
|
|
add_offset: offset || 0, |
|
|
limit: limit || 0 |
|
|
}, { |
|
|
timeout: 300, |
|
|
noErrorBox: true |
|
|
}).then(function (historyResult) { |
|
|
AppUsersManager.saveApiUsers(historyResult.users); |
|
|
AppChatsManager.saveApiChats(historyResult.chats); |
|
|
saveMessages(historyResult.messages); |
|
|
|
|
|
if (isChannel) { |
|
|
ApiUpdatesManager.addChannelState(-peerID, historyResult.pts); |
|
|
} |
|
|
|
|
|
var length = historyResult.messages.length; |
|
|
if (length && |
|
|
historyResult.messages[length - 1].deleted) { |
|
|
historyResult.messages.splice(length - 1, 1); |
|
|
length--; |
|
|
historyResult.count--; |
|
|
} |
|
|
|
|
|
if ( |
|
|
peerID < 0 || |
|
|
!AppUsersManager.isBot(peerID) || |
|
|
(length == limit && limit < historyResult.count) |
|
|
) { |
|
|
return historyResult; |
|
|
} |
|
|
|
|
|
return AppProfileManager.getProfile(peerID).then(function (userFull) { |
|
|
var description = userFull.bot_info && userFull.bot_info.description; |
|
|
if (description) { |
|
|
var messageID = tempID--; |
|
|
var message = { |
|
|
_: 'messageService', |
|
|
id: messageID, |
|
|
from_id: peerID, |
|
|
to_id: AppPeersManager.getOutputPeer(peerID), |
|
|
flags: 0, |
|
|
pFlags: {}, |
|
|
date: tsNow(true) + ServerTimeManager.serverTimeOffset, |
|
|
action: { |
|
|
_: 'messageActionBotIntro', |
|
|
description: description |
|
|
} |
|
|
}; |
|
|
saveMessages([message]); |
|
|
historyResult.messages.push(message); |
|
|
if (historyResult.count) { |
|
|
historyResult.count++; |
|
|
} |
|
|
} |
|
|
return historyResult; |
|
|
}); |
|
|
}, function (error) { |
|
|
switch (error.type) { |
|
|
case 'CHANNEL_PRIVATE': |
|
|
var channel = AppChatsManager.getChat(-peerID); |
|
|
channel = {_: 'channelForbidden', access_hash: channel.access_hash, title: channel.title}; |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updates', |
|
|
updates: [{ |
|
|
_: 'updateChannel', |
|
|
channel_id: -peerID |
|
|
}], |
|
|
chats: [channel], |
|
|
users: [] |
|
|
}); |
|
|
break; |
|
|
} |
|
|
return $q.reject(error); |
|
|
}); |
|
|
} |
|
|
|
|
|
function fillHistoryStorage (peerID, maxID, fullLimit, historyStorage) { |
|
|
// console.log('fill history storage', peerID, maxID, fullLimit, angular.copy(historyStorage)); |
|
|
var offset = (migratedFromTo[peerID] && !maxID) ? 1 : 0; |
|
|
return requestHistory(peerID, maxID, fullLimit, offset).then(function (historyResult) { |
|
|
historyStorage.count = historyResult.count || historyResult.messages.length; |
|
|
|
|
|
var offset = 0; |
|
|
if (!maxID && historyResult.messages.length) { |
|
|
maxID = historyResult.messages[0].mid + 1; |
|
|
} |
|
|
if (maxID > 0) { |
|
|
for (offset = 0; offset < historyStorage.history.length; offset++) { |
|
|
if (maxID > historyStorage.history[offset]) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
var wasTotalCount = historyStorage.history.length; |
|
|
|
|
|
historyStorage.history.splice(offset, historyStorage.history.length - offset); |
|
|
angular.forEach(historyResult.messages, function (message) { |
|
|
if (mergeReplyKeyboard(historyStorage, message)) { |
|
|
$rootScope.$broadcast('history_reply_markup', {peerID: peerID}); |
|
|
} |
|
|
historyStorage.history.push(message.mid); |
|
|
}); |
|
|
|
|
|
var totalCount = historyStorage.history.length; |
|
|
fullLimit -= (totalCount - wasTotalCount); |
|
|
|
|
|
var migratedNextPeer = migratedFromTo[peerID]; |
|
|
var migratedPrevPeer = migratedToFrom[peerID]; |
|
|
var isMigrated = migratedNextPeer !== undefined || migratedPrevPeer !== undefined; |
|
|
|
|
|
if (isMigrated) { |
|
|
historyStorage.count = Math.max(historyStorage.count, totalCount) + 1; |
|
|
} |
|
|
|
|
|
if (fullLimit > 0) { |
|
|
maxID = historyStorage.history[totalCount - 1]; |
|
|
if (isMigrated) { |
|
|
if (!historyResult.messages.length) { |
|
|
if (migratedPrevPeer) { |
|
|
maxID = 0; |
|
|
peerID = migratedPrevPeer; |
|
|
} else { |
|
|
historyStorage.count = totalCount; |
|
|
return true; |
|
|
} |
|
|
} |
|
|
return fillHistoryStorage(peerID, maxID, fullLimit, historyStorage); |
|
|
} |
|
|
else if (totalCount < historyStorage.count) { |
|
|
return fillHistoryStorage(peerID, maxID, fullLimit, historyStorage); |
|
|
} |
|
|
} |
|
|
return true; |
|
|
}); |
|
|
}; |
|
|
|
|
|
function wrapHistoryResult (peerID, result) { |
|
|
var unreadOffset = result.unreadOffset; |
|
|
if (unreadOffset) { |
|
|
var i, message; |
|
|
for (i = result.history.length - 1; i >= 0; i--) { |
|
|
message = messagesStorage[result.history[i]]; |
|
|
if (message && !message.pFlags.out && message.pFlags.unread) { |
|
|
result.unreadOffset = i + 1; |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
return $q.when(result); |
|
|
} |
|
|
|
|
|
function migrateChecks (migrateFrom, migrateTo) { |
|
|
if (!migratedFromTo[migrateFrom] && |
|
|
!migratedToFrom[migrateTo] && |
|
|
AppChatsManager.hasChat(-migrateTo)) { |
|
|
|
|
|
var fromChat = AppChatsManager.getChat(-migrateFrom); |
|
|
if (fromChat && |
|
|
fromChat.migrated_to && |
|
|
fromChat.migrated_to.channel_id == -migrateTo) { |
|
|
migratedFromTo[migrateFrom] = migrateTo; |
|
|
migratedToFrom[migrateTo] = migrateFrom; |
|
|
|
|
|
$timeout(function () { |
|
|
var foundDialog = getDialogByPeerID(migrateFrom); |
|
|
if (foundDialog.length) { |
|
|
dialogsStorage.dialogs.splice(foundDialog[1], 1); |
|
|
$rootScope.$broadcast('dialog_drop', {peerID: migrateFrom}); |
|
|
} |
|
|
$rootScope.$broadcast('dialog_migrate', {migrateFrom: migrateFrom, migrateTo: migrateTo}); |
|
|
}, 100); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
function convertMigratedPeer (peerID) { |
|
|
if (migratedFromTo[peerID]) { |
|
|
return migratedFromTo[peerID]; |
|
|
} |
|
|
} |
|
|
|
|
|
function getHistory (peerID, maxID, limit, backLimit, prerendered) { |
|
|
if (migratedFromTo[peerID]) { |
|
|
peerID = migratedFromTo[peerID]; |
|
|
} |
|
|
var historyStorage = historiesStorage[peerID], |
|
|
offset = 0, |
|
|
offsetNotFound = false, |
|
|
unreadOffset = false, |
|
|
unreadSkip = false; |
|
|
|
|
|
prerendered = prerendered ? Math.min(50, prerendered) : 0; |
|
|
|
|
|
if (historyStorage === undefined) { |
|
|
historyStorage = historiesStorage[peerID] = {count: null, history: [], pending: []}; |
|
|
} |
|
|
|
|
|
var isMigrated = false; |
|
|
var reqPeerID = peerID; |
|
|
if (migratedToFrom[peerID]) { |
|
|
isMigrated = true; |
|
|
if (maxID && maxID < fullMsgIDModulus) { |
|
|
reqPeerID = migratedToFrom[peerID]; |
|
|
} |
|
|
} |
|
|
|
|
|
if (!limit && !maxID) { |
|
|
var foundDialog = getDialogByPeerID(peerID)[0]; |
|
|
if (foundDialog && foundDialog.unread_count > 1) { |
|
|
var unreadCount = foundDialog.unread_count; |
|
|
if (unreadSkip = (unreadCount > 50)) { |
|
|
if (foundDialog.read_inbox_max_id) { |
|
|
maxID = foundDialog.read_inbox_max_id; |
|
|
backLimit = 16; |
|
|
unreadOffset = 16; |
|
|
limit = 4; |
|
|
} else { |
|
|
limit = 20; |
|
|
unreadOffset = 16; |
|
|
offset = unreadCount - unreadOffset; |
|
|
} |
|
|
} else { |
|
|
limit = Math.max(10, prerendered, unreadCount + 2); |
|
|
unreadOffset = unreadCount; |
|
|
} |
|
|
} |
|
|
else if (Config.Mobile) { |
|
|
limit = 20; |
|
|
} |
|
|
} |
|
|
if (maxID > 0) { |
|
|
offsetNotFound = true; |
|
|
for (offset = 0; offset < historyStorage.history.length; offset++) { |
|
|
if (maxID > historyStorage.history[offset]) { |
|
|
offsetNotFound = false; |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
if (!offsetNotFound && ( |
|
|
historyStorage.count !== null && historyStorage.history.length == historyStorage.count || |
|
|
historyStorage.history.length >= offset + (limit || 1) |
|
|
)) { |
|
|
if (backLimit) { |
|
|
backLimit = Math.min(offset, backLimit); |
|
|
offset = Math.max(0, offset - backLimit); |
|
|
limit += backLimit; |
|
|
} else { |
|
|
limit = limit || (offset ? 20 : (prerendered || 5)); |
|
|
} |
|
|
var history = historyStorage.history.slice(offset, offset + limit); |
|
|
if (!maxID && historyStorage.pending.length) { |
|
|
history = historyStorage.pending.slice().concat(history); |
|
|
} |
|
|
return wrapHistoryResult(peerID, { |
|
|
count: historyStorage.count, |
|
|
history: history, |
|
|
unreadOffset: unreadOffset, |
|
|
unreadSkip: unreadSkip |
|
|
}); |
|
|
} |
|
|
|
|
|
if (!backLimit && !limit) { |
|
|
limit = prerendered || 20; |
|
|
} |
|
|
if (offsetNotFound) { |
|
|
offset = 0; |
|
|
} |
|
|
if (backLimit || unreadSkip || maxID && historyStorage.history.indexOf(maxID) == -1) { |
|
|
if (backLimit) { |
|
|
offset = -backLimit; |
|
|
limit += backLimit; |
|
|
} |
|
|
return requestHistory(reqPeerID, maxID, limit, offset).then(function (historyResult) { |
|
|
historyStorage.count = historyResult.count || historyResult.messages.length; |
|
|
if (isMigrated) { |
|
|
historyStorage.count++; |
|
|
} |
|
|
|
|
|
var history = []; |
|
|
angular.forEach(historyResult.messages, function (message) { |
|
|
history.push(message.mid); |
|
|
}); |
|
|
if (!maxID && historyStorage.pending.length) { |
|
|
history = historyStorage.pending.slice().concat(history); |
|
|
} |
|
|
|
|
|
return wrapHistoryResult(peerID, { |
|
|
count: historyStorage.count, |
|
|
history: history, |
|
|
unreadOffset: unreadOffset, |
|
|
unreadSkip: unreadSkip |
|
|
}); |
|
|
}) |
|
|
} |
|
|
|
|
|
return fillHistoryStorage(peerID, maxID, limit, historyStorage).then(function () { |
|
|
offset = 0; |
|
|
if (maxID > 0) { |
|
|
for (offset = 0; offset < historyStorage.history.length; offset++) { |
|
|
if (maxID > historyStorage.history[offset]) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
var history = historyStorage.history.slice(offset, offset + limit); |
|
|
if (!maxID && historyStorage.pending.length) { |
|
|
history = historyStorage.pending.slice().concat(history); |
|
|
} |
|
|
|
|
|
return wrapHistoryResult(peerID, { |
|
|
count: historyStorage.count, |
|
|
history: history, |
|
|
unreadOffset: unreadOffset, |
|
|
unreadSkip: unreadSkip |
|
|
}); |
|
|
}); |
|
|
} |
|
|
|
|
|
function getReplyKeyboard (peerID) { |
|
|
return (historiesStorage[peerID] || {}).reply_markup || false; |
|
|
} |
|
|
|
|
|
function mergeReplyKeyboard (historyStorage, message) { |
|
|
// console.log('merge', message.mid, message.reply_markup, historyStorage.reply_markup); |
|
|
if (!message.reply_markup && |
|
|
!message.pFlags.out && |
|
|
!message.action) { |
|
|
return false; |
|
|
} |
|
|
if (message.reply_markup && |
|
|
message.reply_markup._ == 'replyInlineMarkup') { |
|
|
return false; |
|
|
} |
|
|
var messageReplyMarkup = message.reply_markup; |
|
|
var lastReplyMarkup = historyStorage.reply_markup; |
|
|
if (messageReplyMarkup) { |
|
|
if (lastReplyMarkup && lastReplyMarkup.mid >= message.mid) { |
|
|
return false; |
|
|
} |
|
|
if (messageReplyMarkup.pFlags.selective && |
|
|
!(message.flags & 16)) { |
|
|
return false; |
|
|
} |
|
|
if (historyStorage.maxOutID && |
|
|
message.mid < historyStorage.maxOutID && |
|
|
messageReplyMarkup.pFlags.single_use) { |
|
|
messageReplyMarkup.pFlags.hidden = true; |
|
|
} |
|
|
messageReplyMarkup = angular.extend({ |
|
|
mid: message.mid |
|
|
}, messageReplyMarkup); |
|
|
if (messageReplyMarkup._ != 'replyKeyboardHide') { |
|
|
messageReplyMarkup.fromID = message.from_id; |
|
|
} |
|
|
historyStorage.reply_markup = messageReplyMarkup; |
|
|
// console.log('set', historyStorage.reply_markup); |
|
|
return true; |
|
|
} |
|
|
|
|
|
if (message.pFlags.out) { |
|
|
if (lastReplyMarkup) { |
|
|
if (lastReplyMarkup.pFlags.single_use && |
|
|
!lastReplyMarkup.pFlags.hidden && |
|
|
(message.mid > lastReplyMarkup.mid || message.mid < 0) && |
|
|
message.message) { |
|
|
lastReplyMarkup.pFlags.hidden = true; |
|
|
// console.log('set', historyStorage.reply_markup); |
|
|
return true; |
|
|
} |
|
|
} else if (!historyStorage.maxOutID || |
|
|
message.mid > historyStorage.maxOutID) { |
|
|
historyStorage.maxOutID = message.mid; |
|
|
} |
|
|
} |
|
|
|
|
|
if (message.action && |
|
|
message.action._ == 'messageActionChatDeleteUser' && |
|
|
(lastReplyMarkup |
|
|
? message.action.user_id == lastReplyMarkup.fromID |
|
|
: AppUsersManager.isBot(message.action.user_id) |
|
|
) |
|
|
) { |
|
|
historyStorage.reply_markup = { |
|
|
_: 'replyKeyboardHide', |
|
|
mid: message.mid, |
|
|
flags: 0, |
|
|
pFlags: {} |
|
|
}; |
|
|
// console.log('set', historyStorage.reply_markup); |
|
|
return true; |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
function getSearch (peerID, query, inputFilter, maxID, limit) { |
|
|
var foundMsgs = [], |
|
|
useSearchCache = !query, |
|
|
newSearchFilter = {peer: peerID, filter: inputFilter}, |
|
|
sameSearchCache = useSearchCache && angular.equals(lastSearchFilter, newSearchFilter); |
|
|
|
|
|
if (useSearchCache && !sameSearchCache) { |
|
|
lastSearchFilter = newSearchFilter; |
|
|
lastSearchResults = []; |
|
|
} |
|
|
|
|
|
if (peerID && !maxID && !query) { |
|
|
var historyStorage = historiesStorage[peerID]; |
|
|
|
|
|
if (historyStorage !== undefined && historyStorage.history.length) { |
|
|
var neededContents = {}, |
|
|
neededDocType, |
|
|
neededLimit = limit || 20, |
|
|
i, message; |
|
|
|
|
|
switch (inputFilter._) { |
|
|
case 'inputMessagesFilterPhotos': |
|
|
neededContents['messageMediaPhoto'] = true; |
|
|
break; |
|
|
|
|
|
case 'inputMessagesFilterPhotoVideo': |
|
|
neededContents['messageMediaPhoto'] = true; |
|
|
neededContents['messageMediaDocument'] = true; |
|
|
neededDocType = 'video'; |
|
|
break; |
|
|
|
|
|
case 'inputMessagesFilterVideo': |
|
|
neededContents['messageMediaDocument'] = true; |
|
|
neededDocType = 'video'; |
|
|
break; |
|
|
|
|
|
case 'inputMessagesFilterDocument': |
|
|
neededContents['messageMediaDocument'] = true; |
|
|
neededDocType = false; |
|
|
break; |
|
|
|
|
|
case 'inputMessagesFilterVoice': |
|
|
neededContents['messageMediaDocument'] = true; |
|
|
neededDocType = 'voice'; |
|
|
break; |
|
|
} |
|
|
for (i = 0; i < historyStorage.history.length; i++) { |
|
|
message = messagesStorage[historyStorage.history[i]]; |
|
|
if (message.media && neededContents[message.media._]) { |
|
|
if (neededDocType !== undefined && |
|
|
message.media._ == 'messageMediaDocument' && |
|
|
message.media.document.type != neededDocType) { |
|
|
continue; |
|
|
} |
|
|
foundMsgs.push(message.mid); |
|
|
if (foundMsgs.length >= neededLimit) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
// console.log(dT(), sameSearchCache, foundMsgs, lastSearchResults); |
|
|
if (foundMsgs.length < neededLimit && lastSearchResults.length && sameSearchCache) { |
|
|
var minID = foundMsgs.length ? foundMsgs[foundMsgs.length - 1] : 0xFFFFFFFF; |
|
|
for (var i = 0; i < lastSearchResults.length; i++) { |
|
|
if (lastSearchResults[i] < minID) { |
|
|
foundMsgs.push(lastSearchResults[i]); |
|
|
if (foundMsgs.length >= neededLimit) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
// console.log(dT(), foundMsgs); |
|
|
} |
|
|
|
|
|
if (foundMsgs.length || limit == 1000) { |
|
|
if (useSearchCache) { |
|
|
lastSearchResults = listMergeSorted(lastSearchResults, foundMsgs); |
|
|
} |
|
|
|
|
|
return $q.when({ |
|
|
count: null, |
|
|
history: foundMsgs |
|
|
}); |
|
|
} |
|
|
|
|
|
var apiPromise; |
|
|
|
|
|
if (peerID || !query) { |
|
|
var flags = 0; |
|
|
if (AppPeersManager.isChannel(peerID) && |
|
|
!AppPeersManager.isMegagroup(peerID)) { |
|
|
flags |= 1; |
|
|
} |
|
|
apiPromise = MtpApiManager.invokeApi('messages.search', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
q: query || '', |
|
|
filter: inputFilter || {_: 'inputMessagesFilterEmpty'}, |
|
|
min_date: 0, |
|
|
max_date: 0, |
|
|
limit: limit || 20, |
|
|
max_id: maxID || 0 |
|
|
}, { |
|
|
timeout: 300, |
|
|
noErrorBox: true |
|
|
}); |
|
|
} else { |
|
|
var offsetDate = 0; |
|
|
var offsetPeerID = 0; |
|
|
var offsetID = 0; |
|
|
var offsetMessage = maxID && getMessage(maxID); |
|
|
|
|
|
if (offsetMessage && offsetMessage.date) { |
|
|
offsetDate = offsetMessage.date + ServerTimeManager.serverTimeOffset; |
|
|
offsetID = offsetMessage.id; |
|
|
offsetPeerID = getMessagePeer(offsetMessage); |
|
|
} |
|
|
apiPromise = MtpApiManager.invokeApi('messages.searchGlobal', { |
|
|
q: query, |
|
|
offset_date: offsetDate, |
|
|
offset_peer: AppPeersManager.getInputPeerByID(offsetPeerID), |
|
|
offset_id: AppMessagesIDsManager.getMessageLocalID(offsetID), |
|
|
limit: limit || 20 |
|
|
}, { |
|
|
timeout: 300, |
|
|
noErrorBox: true |
|
|
}); |
|
|
} |
|
|
|
|
|
return apiPromise.then(function (searchResult) { |
|
|
AppUsersManager.saveApiUsers(searchResult.users); |
|
|
AppChatsManager.saveApiChats(searchResult.chats); |
|
|
saveMessages(searchResult.messages); |
|
|
|
|
|
var foundCount = searchResult.count || searchResult.messages.length; |
|
|
|
|
|
foundMsgs = []; |
|
|
angular.forEach(searchResult.messages, function (message) { |
|
|
var peerID = getMessagePeer(message); |
|
|
if (peerID < 0) { |
|
|
var chat = AppChatsManager.getChat(-peerID); |
|
|
if (chat.migrated_to) { |
|
|
migrateChecks(peerID, -chat.migrated_to.channel_id); |
|
|
} |
|
|
} |
|
|
foundMsgs.push(message.mid); |
|
|
}); |
|
|
|
|
|
if (useSearchCache) { |
|
|
lastSearchResults = listMergeSorted(lastSearchResults, foundMsgs); |
|
|
} |
|
|
|
|
|
return { |
|
|
count: foundCount, |
|
|
history: foundMsgs |
|
|
}; |
|
|
}, function (error) { |
|
|
if (error.code == 400) { |
|
|
error.handled = true; |
|
|
} |
|
|
return $q.reject(error); |
|
|
}); |
|
|
} |
|
|
|
|
|
function getMessage (messageID) { |
|
|
return messagesStorage[messageID] || {deleted: true}; |
|
|
} |
|
|
|
|
|
function deleteMessages (messageIDs) { |
|
|
var splitted = AppMessagesIDsManager.splitMessageIDsByChannels(messageIDs); |
|
|
var promises = []; |
|
|
angular.forEach(splitted.msgIDs, function (msgIDs, channelID) { |
|
|
var promise; |
|
|
if (channelID > 0) { |
|
|
var channel = AppChatsManager.getChat(channelID); |
|
|
if (!channel.pFlags.creator && !(channel.pFlags.editor && channel.pFlags.megagroup)) { |
|
|
var goodMsgIDs = []; |
|
|
if (channel.pFlags.editor || channel.pFlags.megagroup) { |
|
|
angular.forEach(msgIDs, function (msgID, i) { |
|
|
var message = getMessage(splitted.mids[channelID][i]); |
|
|
if (message.pFlags.out) { |
|
|
goodMsgIDs.push(msgID); |
|
|
} |
|
|
}); |
|
|
} |
|
|
if (!goodMsgIDs.length) { |
|
|
return; |
|
|
} |
|
|
msgIDs = goodMsgIDs; |
|
|
} |
|
|
promise = MtpApiManager.invokeApi('channels.deleteMessages', { |
|
|
channel: AppChatsManager.getChannelInput(channelID), |
|
|
id: msgIDs |
|
|
}).then(function (affectedMessages) { |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updateDeleteChannelMessages', |
|
|
channel_id: channelID, |
|
|
messages: msgIDs, |
|
|
pts: affectedMessages.pts, |
|
|
pts_count: affectedMessages.pts_count |
|
|
} |
|
|
}); |
|
|
}); |
|
|
} else { |
|
|
promise = MtpApiManager.invokeApi('messages.deleteMessages', { |
|
|
id: msgIDs |
|
|
}).then(function (affectedMessages) { |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updateDeleteMessages', |
|
|
messages: msgIDs, |
|
|
pts: affectedMessages.pts, |
|
|
pts_count: affectedMessages.pts_count |
|
|
} |
|
|
}); |
|
|
}); |
|
|
} |
|
|
promises.push(promise); |
|
|
}); |
|
|
|
|
|
return $q.all(promises); |
|
|
} |
|
|
|
|
|
function getMessageShareLink(fullMsgID) { |
|
|
var info = AppMessagesIDsManager.getMessageIDInfo(fullMsgID); |
|
|
var msgID = info[0]; |
|
|
var channelID = info[1]; |
|
|
if (!channelID) { |
|
|
return $q.reject(); |
|
|
} |
|
|
var message = getMessage(fullMsgID); |
|
|
if (!message || !message.pFlags || !message.pFlags.post) { |
|
|
return $q.reject(); |
|
|
} |
|
|
return MtpApiManager.invokeApi('channels.exportMessageLink', { |
|
|
channel: AppChatsManager.getChannelInput(channelID), |
|
|
id: msgID |
|
|
}).then(function (exportedMessageLink) { |
|
|
return exportedMessageLink.link; |
|
|
}); |
|
|
} |
|
|
|
|
|
function readHistory (peerID) { |
|
|
// console.trace('start read'); |
|
|
var isChannel = AppPeersManager.isChannel(peerID), |
|
|
historyStorage = historiesStorage[peerID], |
|
|
foundDialog = getDialogByPeerID(peerID)[0]; |
|
|
|
|
|
if (!foundDialog || !foundDialog.unread_count) { |
|
|
|
|
|
if (!historyStorage || !historyStorage.history.length) { |
|
|
return false; |
|
|
} |
|
|
|
|
|
var messageID, |
|
|
message, |
|
|
foundUnread = false; |
|
|
for (i = historyStorage.history.length; i >= 0; i--) { |
|
|
messageID = historyStorage.history[i]; |
|
|
message = messagesStorage[messageID]; |
|
|
if (message && !message.pFlags.out && message.pFlags.unread) { |
|
|
foundUnread = true; |
|
|
break; |
|
|
} |
|
|
} |
|
|
if (!foundUnread) { |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
if (historyStorage.readPromise) { |
|
|
return historyStorage.readPromise; |
|
|
} |
|
|
|
|
|
var apiPromise; |
|
|
if (isChannel) { |
|
|
apiPromise = MtpApiManager.invokeApi('channels.readHistory', { |
|
|
channel: AppChatsManager.getChannelInput(-peerID), |
|
|
max_id: 0 |
|
|
}); |
|
|
} else { |
|
|
apiPromise = MtpApiManager.invokeApi('messages.readHistory', { |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
max_id: 0 |
|
|
}).then(function (affectedMessages) { |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updatePts', |
|
|
pts: affectedMessages.pts, |
|
|
pts_count: affectedMessages.pts_count |
|
|
} |
|
|
}); |
|
|
}) |
|
|
} |
|
|
|
|
|
historyStorage.readPromise = apiPromise.then(function () { |
|
|
if (foundDialog) { |
|
|
// console.log('done read history', peerID); |
|
|
foundDialog.unread_count = 0; |
|
|
$rootScope.$broadcast('dialog_unread', {peerID: peerID, count: 0}); |
|
|
$rootScope.$broadcast('messages_read'); |
|
|
if (historyStorage && historyStorage.history.length) { |
|
|
foundDialog.read_inbox_max_id = historyStorage.history[0]; |
|
|
} |
|
|
} |
|
|
})['finally'](function () { |
|
|
delete historyStorage.readPromise; |
|
|
}); |
|
|
|
|
|
if (historyStorage && historyStorage.history.length) { |
|
|
var messageID, message, i, peerID, foundDialog, dialog; |
|
|
for (i = 0; i < historyStorage.history.length; i++) { |
|
|
messageID = historyStorage.history[i]; |
|
|
message = messagesStorage[messageID]; |
|
|
if (message && !message.pFlags.out) { |
|
|
message.pFlags.unread = false; |
|
|
if (messagesForHistory[messageID]) { |
|
|
messagesForHistory[messageID].pFlags.unread = false; |
|
|
} |
|
|
if (messagesForDialogs[messageID]) { |
|
|
messagesForDialogs[messageID].pFlags.unread = false; |
|
|
} |
|
|
NotificationsManager.cancel('msg' + messageID); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
NotificationsManager.soundReset(AppPeersManager.getPeerString(peerID)) |
|
|
|
|
|
return historyStorage.readPromise; |
|
|
} |
|
|
|
|
|
function readMessages (messageIDs) { |
|
|
MtpApiManager.invokeApi('messages.readMessageContents', { |
|
|
id: messageIDs |
|
|
}).then(function (affectedMessages) { |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updateReadMessagesContents', |
|
|
messages: messageIDs, |
|
|
pts: affectedMessages.pts, |
|
|
pts_count: affectedMessages.pts_count |
|
|
} |
|
|
}); |
|
|
}); |
|
|
} |
|
|
|
|
|
function doFlushHistory (inputPeer, justClear) { |
|
|
var flags = 0; |
|
|
if (justClear) { |
|
|
flags |= 1; |
|
|
} |
|
|
return MtpApiManager.invokeApi('messages.deleteHistory', { |
|
|
flags: flags, |
|
|
peer: inputPeer, |
|
|
max_id: 0 |
|
|
}).then(function (affectedHistory) { |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updatePts', |
|
|
pts: affectedHistory.pts, |
|
|
pts_count: affectedHistory.pts_count |
|
|
} |
|
|
}); |
|
|
if (!affectedHistory.offset) { |
|
|
return true; |
|
|
} |
|
|
return doFlushHistory(inputPeer, justClear); |
|
|
}); |
|
|
} |
|
|
|
|
|
function flushHistory (peerID, justClear) { |
|
|
return doFlushHistory(AppPeersManager.getInputPeerByID(peerID), justClear).then(function () { |
|
|
if (justClear) { |
|
|
$rootScope.$broadcast('dialog_flush', {peerID: peerID}); |
|
|
} else { |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
if (foundDialog[0]) { |
|
|
dialogsStorage.dialogs.splice(foundDialog[1], 1); |
|
|
} |
|
|
delete historiesStorage[peerID]; |
|
|
$rootScope.$broadcast('dialog_drop', {peerID: peerID}); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
function saveMessages (apiMessages, options) { |
|
|
options = options || {}; |
|
|
angular.forEach(apiMessages, function (apiMessage) { |
|
|
if (apiMessage.pFlags === undefined) { |
|
|
apiMessage.pFlags = {}; |
|
|
} |
|
|
if (!apiMessage.pFlags.out) { |
|
|
apiMessage.pFlags.out = false; |
|
|
} |
|
|
if (!apiMessage.pFlags.unread) { |
|
|
apiMessage.pFlags.unread = false; |
|
|
} |
|
|
if (apiMessage._ == 'messageEmpty') { |
|
|
return; |
|
|
} |
|
|
|
|
|
var toPeerID = AppPeersManager.getPeerID(apiMessage.to_id); |
|
|
var isChannel = apiMessage.to_id._ == 'peerChannel'; |
|
|
var channelID = isChannel ? -toPeerID : 0; |
|
|
var isBroadcast = isChannel && !AppChatsManager.isMegagroup(channelID); |
|
|
|
|
|
var mid = AppMessagesIDsManager.getFullMessageID(apiMessage.id, channelID); |
|
|
apiMessage.mid = mid; |
|
|
|
|
|
var dialog = getDialogByPeerID(toPeerID)[0]; |
|
|
if (dialog && mid > 0) { |
|
|
var dialogKey = apiMessage.pFlags.out |
|
|
? 'read_outbox_max_id' |
|
|
: 'read_inbox_max_id'; |
|
|
|
|
|
apiMessage.pFlags.unread = mid > dialog[dialogKey]; |
|
|
} |
|
|
else if (options.isNew) { |
|
|
apiMessage.pFlags.unread = true; |
|
|
} |
|
|
|
|
|
if (apiMessage.reply_to_msg_id) { |
|
|
apiMessage.reply_to_mid = AppMessagesIDsManager.getFullMessageID(apiMessage.reply_to_msg_id, channelID); |
|
|
} |
|
|
|
|
|
apiMessage.date -= ServerTimeManager.serverTimeOffset; |
|
|
|
|
|
var fwdHeader = apiMessage.fwd_from; |
|
|
if (fwdHeader) { |
|
|
apiMessage.fwdFromID = fwdHeader.channel_id ? -fwdHeader.channel_id : fwdHeader.from_id; |
|
|
fwdHeader.date -= ServerTimeManager.serverTimeOffset; |
|
|
} |
|
|
|
|
|
apiMessage.toID = toPeerID; |
|
|
apiMessage.fromID = apiMessage.pFlags.post ? toPeerID : apiMessage.from_id; |
|
|
apiMessage.signID = apiMessage.pFlags.post && apiMessage.from_id || |
|
|
fwdHeader && fwdHeader.channel_id && fwdHeader.from_id; |
|
|
|
|
|
if (apiMessage.via_bot_id > 0) { |
|
|
apiMessage.viaBotID = apiMessage.via_bot_id; |
|
|
} |
|
|
|
|
|
var mediaContext = { |
|
|
user_id: apiMessage.fromID, |
|
|
date: apiMessage.date |
|
|
}; |
|
|
|
|
|
if (apiMessage.media) { |
|
|
switch (apiMessage.media._) { |
|
|
case 'messageMediaEmpty': |
|
|
delete apiMessage.media; |
|
|
break; |
|
|
case 'messageMediaPhoto': |
|
|
AppPhotosManager.savePhoto(apiMessage.media.photo, mediaContext); |
|
|
break; |
|
|
case 'messageMediaDocument': |
|
|
AppDocsManager.saveDoc(apiMessage.media.document, mediaContext); |
|
|
break; |
|
|
case 'messageMediaWebPage': |
|
|
AppWebPagesManager.saveWebPage(apiMessage.media.webpage, apiMessage.mid, mediaContext); |
|
|
break; |
|
|
} |
|
|
} |
|
|
if (apiMessage.action) { |
|
|
var migrateFrom, migrateTo; |
|
|
switch (apiMessage.action._) { |
|
|
case 'messageActionChatEditPhoto': |
|
|
AppPhotosManager.savePhoto(apiMessage.action.photo, mediaContext); |
|
|
if (isBroadcast) { |
|
|
apiMessage.action._ = 'messageActionChannelEditPhoto'; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageActionChatEditTitle': |
|
|
if (isBroadcast) { |
|
|
apiMessage.action._ = 'messageActionChannelEditTitle'; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageActionChatDeletePhoto': |
|
|
if (isBroadcast) { |
|
|
apiMessage.action._ = 'messageActionChannelDeletePhoto'; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageActionChatAddUser': |
|
|
if (apiMessage.action.users.length == 1) { |
|
|
apiMessage.action.user_id = apiMessage.action.users[0]; |
|
|
if (apiMessage.fromID == apiMessage.action.user_id) { |
|
|
if (isChannel) { |
|
|
apiMessage.action._ = 'messageActionChatJoined'; |
|
|
} else { |
|
|
apiMessage.action._ = 'messageActionChatReturn'; |
|
|
} |
|
|
} |
|
|
} |
|
|
else if (apiMessage.action.users.length > 1) { |
|
|
apiMessage.action._ = 'messageActionChatAddUsers'; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageActionChatDeleteUser': |
|
|
if (apiMessage.fromID == apiMessage.action.user_id) { |
|
|
apiMessage.action._ = 'messageActionChatLeave'; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageActionChannelMigrateFrom': |
|
|
migrateFrom = -apiMessage.action.chat_id; |
|
|
migrateTo = -channelID; |
|
|
break; |
|
|
|
|
|
case 'messageActionChatMigrateTo': |
|
|
migrateFrom = -channelID; |
|
|
migrateTo = -apiMessage.action.channel_id; |
|
|
break; |
|
|
|
|
|
case 'messageActionHistoryClear': |
|
|
apiMessage.deleted = true; |
|
|
apiMessage.clear_history = true; |
|
|
apiMessage.pFlags.out = false; |
|
|
apiMessage.pFlags.unread = false; |
|
|
break; |
|
|
} |
|
|
if (migrateFrom && |
|
|
migrateTo && |
|
|
!migratedFromTo[migrateFrom] && |
|
|
!migratedToFrom[migrateTo]) { |
|
|
migrateChecks(migrateFrom, migrateTo); |
|
|
} |
|
|
} |
|
|
|
|
|
if (apiMessage.message && apiMessage.message.length) { |
|
|
var myEntities = RichTextProcessor.parseEntities(apiMessage.message); |
|
|
var apiEntities = apiMessage.entities || []; |
|
|
apiMessage.totalEntities = RichTextProcessor.mergeEntities(myEntities, apiEntities, !apiMessage.pending); |
|
|
} |
|
|
|
|
|
if (!options.isEdited) { |
|
|
messagesStorage[mid] = apiMessage; |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
function sendText(peerID, text, options) { |
|
|
if (!angular.isString(text)) { |
|
|
return; |
|
|
} |
|
|
options = options || {}; |
|
|
var entities = options.entities || []; |
|
|
if (!options.viaBotID) { |
|
|
text = RichTextProcessor.parseMarkdown(text, entities); |
|
|
} |
|
|
if (!text.length) { |
|
|
return; |
|
|
} |
|
|
|
|
|
var messageID = tempID--, |
|
|
randomID = [nextRandomInt(0xFFFFFFFF), nextRandomInt(0xFFFFFFFF)], |
|
|
randomIDS = bigint(randomID[0]).shiftLeft(32).add(bigint(randomID[1])).toString(), |
|
|
historyStorage = historiesStorage[peerID], |
|
|
flags = 0, |
|
|
pFlags = {}, |
|
|
replyToMsgID = options.replyToMsgID, |
|
|
isChannel = AppPeersManager.isChannel(peerID), |
|
|
isMegagroup = isChannel && AppPeersManager.isMegagroup(peerID), |
|
|
asChannel = isChannel && !isMegagroup ? true : false, |
|
|
message; |
|
|
|
|
|
if (historyStorage === undefined) { |
|
|
historyStorage = historiesStorage[peerID] = {count: null, history: [], pending: []}; |
|
|
} |
|
|
|
|
|
var fromID = AppUsersManager.getSelf().id; |
|
|
if (peerID != fromID) { |
|
|
flags |= 2; |
|
|
pFlags.out = true; |
|
|
if (!isChannel && !AppUsersManager.isBot(peerID)) { |
|
|
flags |= 1; |
|
|
pFlags.unread = true; |
|
|
} |
|
|
} |
|
|
if (replyToMsgID) { |
|
|
flags |= 8; |
|
|
} |
|
|
if (asChannel) { |
|
|
fromID = 0; |
|
|
} else { |
|
|
flags |= 256; |
|
|
} |
|
|
message = { |
|
|
_: 'message', |
|
|
id: messageID, |
|
|
from_id: fromID, |
|
|
to_id: AppPeersManager.getOutputPeer(peerID), |
|
|
flags: flags, |
|
|
pFlags: pFlags, |
|
|
date: tsNow(true) + ServerTimeManager.serverTimeOffset, |
|
|
message: text, |
|
|
random_id: randomIDS, |
|
|
reply_to_msg_id: replyToMsgID, |
|
|
via_bot_id: options.viaBotID, |
|
|
reply_markup: options.reply_markup, |
|
|
entities: entities, |
|
|
views: asChannel && 1, |
|
|
pending: true |
|
|
}; |
|
|
|
|
|
var toggleError = function (on) { |
|
|
var historyMessage = messagesForHistory[messageID]; |
|
|
if (on) { |
|
|
message.error = true; |
|
|
if (historyMessage) { |
|
|
historyMessage.error = true; |
|
|
} |
|
|
} else { |
|
|
delete message.error; |
|
|
if (historyMessage) { |
|
|
delete historyMessage.error; |
|
|
} |
|
|
} |
|
|
$rootScope.$broadcast('messages_pending'); |
|
|
} |
|
|
|
|
|
message.send = function () { |
|
|
toggleError(false); |
|
|
var sentRequestOptions = {}; |
|
|
if (pendingAfterMsgs[peerID]) { |
|
|
sentRequestOptions.afterMessageID = pendingAfterMsgs[peerID].messageID; |
|
|
} |
|
|
var flags = 0; |
|
|
if (replyToMsgID) { |
|
|
flags |= 1; |
|
|
} |
|
|
if (asChannel) { |
|
|
flags |= 16; |
|
|
} |
|
|
if (options.clearDraft) { |
|
|
flags |= 128; |
|
|
} |
|
|
var apiPromise; |
|
|
if (options.viaBotID) { |
|
|
apiPromise = MtpApiManager.invokeApi('messages.sendInlineBotResult', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
random_id: randomID, |
|
|
reply_to_msg_id: AppMessagesIDsManager.getMessageLocalID(replyToMsgID), |
|
|
query_id: options.queryID, |
|
|
id: options.resultID |
|
|
}, sentRequestOptions); |
|
|
} else { |
|
|
if (entities.length) { |
|
|
flags |= 8; |
|
|
} |
|
|
apiPromise = MtpApiManager.invokeApi('messages.sendMessage', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
message: text, |
|
|
random_id: randomID, |
|
|
reply_to_msg_id: AppMessagesIDsManager.getMessageLocalID(replyToMsgID), |
|
|
entities: entities |
|
|
}, sentRequestOptions) |
|
|
} |
|
|
// console.log(flags, entities); |
|
|
apiPromise.then(function (updates) { |
|
|
if (updates._ == 'updateShortSentMessage') { |
|
|
message.flags = updates.flags; |
|
|
message.date = updates.date; |
|
|
message.id = updates.id; |
|
|
message.media = updates.media; |
|
|
message.entities = updates.entities; |
|
|
updates = { |
|
|
_: 'updates', |
|
|
users: [], |
|
|
chats: [], |
|
|
seq: 0, |
|
|
updates: [{ |
|
|
_: 'updateMessageID', |
|
|
random_id: randomIDS, |
|
|
id: updates.id |
|
|
}, { |
|
|
_: isChannel ? 'updateNewChannelMessage' : 'updateNewMessage', |
|
|
message: message, |
|
|
pts: updates.pts, |
|
|
pts_count: updates.pts_count |
|
|
}] |
|
|
}; |
|
|
} |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
}, function (error) { |
|
|
toggleError(true); |
|
|
})['finally'](function () { |
|
|
if (pendingAfterMsgs[peerID] === sentRequestOptions) { |
|
|
delete pendingAfterMsgs[peerID]; |
|
|
} |
|
|
}); |
|
|
|
|
|
pendingAfterMsgs[peerID] = sentRequestOptions; |
|
|
}; |
|
|
|
|
|
saveMessages([message]); |
|
|
historyStorage.pending.unshift(messageID); |
|
|
$rootScope.$broadcast('history_append', {peerID: peerID, messageID: messageID, my: true}); |
|
|
|
|
|
setZeroTimeout(message.send); |
|
|
// setTimeout(function () { |
|
|
// message.send(); |
|
|
// }, 5000); |
|
|
|
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updateDraftMessage', |
|
|
peer: AppPeersManager.getOutputPeer(peerID), |
|
|
draft: {_: 'draftMessageEmpty'} |
|
|
} |
|
|
}); |
|
|
|
|
|
pendingByRandomID[randomIDS] = [peerID, messageID]; |
|
|
}; |
|
|
|
|
|
function sendFile(peerID, file, options) { |
|
|
options = options || {}; |
|
|
var messageID = tempID--, |
|
|
randomID = [nextRandomInt(0xFFFFFFFF), nextRandomInt(0xFFFFFFFF)], |
|
|
randomIDS = bigint(randomID[0]).shiftLeft(32).add(bigint(randomID[1])).toString(), |
|
|
historyStorage = historiesStorage[peerID], |
|
|
flags = 0, |
|
|
pFlags = {}, |
|
|
replyToMsgID = options.replyToMsgID, |
|
|
isChannel = AppPeersManager.isChannel(peerID), |
|
|
isMegagroup = isChannel && AppPeersManager.isMegagroup(peerID), |
|
|
asChannel = isChannel && !isMegagroup ? true : false, |
|
|
attachType, apiFileName, realFileName; |
|
|
|
|
|
if (!options.isMedia) { |
|
|
attachType = 'document'; |
|
|
apiFileName = 'document.' + file.type.split('/')[1]; |
|
|
} else if (['image/jpeg', 'image/png', 'image/bmp'].indexOf(file.type) >= 0) { |
|
|
attachType = 'photo'; |
|
|
apiFileName = 'photo.' + file.type.split('/')[1]; |
|
|
} else if (file.type.substr(0, 6) == 'audio/' || ['video/ogg'].indexOf(file.type) >= 0) { |
|
|
attachType = 'audio'; |
|
|
apiFileName = 'audio.' + (file.type.split('/')[1] == 'ogg' ? 'ogg' : 'mp3'); |
|
|
} else if (file.type.substr(0, 6) == 'video/') { |
|
|
attachType = 'video'; |
|
|
apiFileName = 'video.mp4'; |
|
|
} else { |
|
|
attachType = 'document'; |
|
|
apiFileName = 'document.' + file.type.split('/')[1]; |
|
|
} |
|
|
|
|
|
console.log(attachType, apiFileName, file.type); |
|
|
|
|
|
if (historyStorage === undefined) { |
|
|
historyStorage = historiesStorage[peerID] = {count: null, history: [], pending: []}; |
|
|
} |
|
|
|
|
|
var fromID = AppUsersManager.getSelf().id; |
|
|
if (peerID != fromID) { |
|
|
flags |= 2; |
|
|
pFlags.out = true; |
|
|
if (!isChannel && !AppUsersManager.isBot(peerID)) { |
|
|
flags |= 1; |
|
|
pFlags.unread = true; |
|
|
} |
|
|
} |
|
|
if (replyToMsgID) { |
|
|
flags |= 8; |
|
|
} |
|
|
if (asChannel) { |
|
|
fromID = 0; |
|
|
} else { |
|
|
flags |= 256; |
|
|
} |
|
|
var media = { |
|
|
_: 'messageMediaPending', |
|
|
type: attachType, |
|
|
file_name: file.name || apiFileName, |
|
|
size: file.size, |
|
|
progress: {percent: 1, total: file.size} |
|
|
}; |
|
|
|
|
|
var message = { |
|
|
_: 'message', |
|
|
id: messageID, |
|
|
from_id: fromID, |
|
|
to_id: AppPeersManager.getOutputPeer(peerID), |
|
|
flags: flags, |
|
|
pFlags: pFlags, |
|
|
date: tsNow(true) + ServerTimeManager.serverTimeOffset, |
|
|
message: '', |
|
|
media: media, |
|
|
random_id: randomIDS, |
|
|
reply_to_msg_id: replyToMsgID, |
|
|
views: asChannel && 1, |
|
|
pending: true |
|
|
}; |
|
|
|
|
|
var toggleError = function (on) { |
|
|
var historyMessage = messagesForHistory[messageID]; |
|
|
if (on) { |
|
|
message.error = true; |
|
|
if (historyMessage) { |
|
|
historyMessage.error = true; |
|
|
} |
|
|
} else { |
|
|
delete message.error; |
|
|
if (historyMessage) { |
|
|
delete historyMessage.error; |
|
|
} |
|
|
} |
|
|
$rootScope.$broadcast('messages_pending'); |
|
|
} |
|
|
|
|
|
var uploaded = false, |
|
|
uploadPromise; |
|
|
|
|
|
message.send = function () { |
|
|
var sendFileDeferred = $q.defer(); |
|
|
|
|
|
sendFilePromise.then(function () { |
|
|
if (!uploaded || message.error) { |
|
|
uploaded = false; |
|
|
uploadPromise = MtpApiFileManager.uploadFile(file); |
|
|
} |
|
|
|
|
|
uploadPromise.then(function (inputFile) { |
|
|
inputFile.name = apiFileName; |
|
|
uploaded = true; |
|
|
var inputMedia; |
|
|
switch (attachType) { |
|
|
case 'photo': |
|
|
inputMedia = {_: 'inputMediaUploadedPhoto', file: inputFile}; |
|
|
break; |
|
|
|
|
|
case 'document': |
|
|
default: |
|
|
inputMedia = {_: 'inputMediaUploadedDocument', file: inputFile, mime_type: file.type, caption: '', attributes: [ |
|
|
{_: 'documentAttributeFilename', file_name: file.name} |
|
|
]}; |
|
|
} |
|
|
var flags = 0; |
|
|
if (replyToMsgID) { |
|
|
flags |= 1; |
|
|
} |
|
|
if (asChannel) { |
|
|
flags |= 16; |
|
|
} |
|
|
MtpApiManager.invokeApi('messages.sendMedia', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
media: inputMedia, |
|
|
random_id: randomID, |
|
|
reply_to_msg_id: AppMessagesIDsManager.getMessageLocalID(replyToMsgID) |
|
|
}).then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
}, function (error) { |
|
|
if (attachType == 'photo' && |
|
|
error.code == 400 && |
|
|
(error.type == 'PHOTO_INVALID_DIMENSIONS' || |
|
|
error.type == 'PHOTO_SAVE_FILE_INVALID')) { |
|
|
error.handled = true; |
|
|
attachType = 'document'; |
|
|
message.send(); |
|
|
return; |
|
|
} |
|
|
toggleError(true); |
|
|
}); |
|
|
}, function (error) { |
|
|
toggleError(true); |
|
|
}, function (progress) { |
|
|
// console.log('upload progress', progress); |
|
|
media.progress.done = progress.done; |
|
|
media.progress.percent = Math.max(1, Math.floor(100 * progress.done / progress.total)); |
|
|
$rootScope.$broadcast('history_update', {peerID: peerID}); |
|
|
}); |
|
|
|
|
|
media.progress.cancel = function () { |
|
|
if (!uploaded) { |
|
|
sendFileDeferred.resolve(); |
|
|
uploadPromise.cancel(); |
|
|
cancelPendingMessage(randomIDS); |
|
|
} |
|
|
} |
|
|
|
|
|
uploadPromise['finally'](function () { |
|
|
sendFileDeferred.resolve(); |
|
|
}); |
|
|
}); |
|
|
|
|
|
sendFilePromise = sendFileDeferred.promise; |
|
|
}; |
|
|
|
|
|
saveMessages([message]); |
|
|
historyStorage.pending.unshift(messageID); |
|
|
$rootScope.$broadcast('history_append', {peerID: peerID, messageID: messageID, my: true}); |
|
|
|
|
|
setZeroTimeout(message.send); |
|
|
|
|
|
pendingByRandomID[randomIDS] = [peerID, messageID]; |
|
|
} |
|
|
|
|
|
function sendOther(peerID, inputMedia, options) { |
|
|
options = options || {}; |
|
|
|
|
|
var messageID = tempID--, |
|
|
randomID = [nextRandomInt(0xFFFFFFFF), nextRandomInt(0xFFFFFFFF)], |
|
|
randomIDS = bigint(randomID[0]).shiftLeft(32).add(bigint(randomID[1])).toString(), |
|
|
historyStorage = historiesStorage[peerID], |
|
|
replyToMsgID = options.replyToMsgID, |
|
|
isChannel = AppPeersManager.isChannel(peerID), |
|
|
isMegagroup = isChannel && AppPeersManager.isMegagroup(peerID), |
|
|
asChannel = isChannel && !isMegagroup ? true : false; |
|
|
|
|
|
if (historyStorage === undefined) { |
|
|
historyStorage = historiesStorage[peerID] = {count: null, history: [], pending: []}; |
|
|
} |
|
|
|
|
|
var fromID = AppUsersManager.getSelf().id; |
|
|
var media; |
|
|
switch (inputMedia._) { |
|
|
case 'inputMediaPhoto': |
|
|
media = { |
|
|
_: 'messageMediaPhoto', |
|
|
photo: AppPhotosManager.getPhoto(inputMedia.id.id), |
|
|
caption: inputMedia.caption || '' |
|
|
}; |
|
|
break; |
|
|
|
|
|
case 'inputMediaDocument': |
|
|
var doc = AppDocsManager.getDoc(inputMedia.id.id); |
|
|
if (doc.sticker && doc.stickerSetInput) { |
|
|
AppStickersManager.pushPopularSticker(doc.id); |
|
|
}; |
|
|
media = { |
|
|
_: 'messageMediaDocument', |
|
|
'document': doc, |
|
|
caption: inputMedia.caption || '' |
|
|
}; |
|
|
break; |
|
|
|
|
|
case 'inputMediaContact': |
|
|
media = { |
|
|
_: 'messageMediaContact', |
|
|
phone_number: inputMedia.phone_number, |
|
|
first_name: inputMedia.first_name, |
|
|
last_name: inputMedia.last_name, |
|
|
user_id: 0 |
|
|
}; |
|
|
break; |
|
|
|
|
|
case 'inputMediaGeoPoint': |
|
|
media = { |
|
|
_: 'messageMediaGeo', |
|
|
geo: { |
|
|
_: 'geoPoint', |
|
|
'lat': inputMedia.geo_point['lat'], |
|
|
'long': inputMedia.geo_point['long'] |
|
|
} |
|
|
}; |
|
|
break; |
|
|
|
|
|
case 'inputMediaVenue': |
|
|
media = { |
|
|
_: 'messageMediaVenue', |
|
|
geo: { |
|
|
_: 'geoPoint', |
|
|
'lat': inputMedia.geo_point['lat'], |
|
|
'long': inputMedia.geo_point['long'] |
|
|
}, |
|
|
title: inputMedia.title, |
|
|
address: inputMedia.address, |
|
|
provider: inputMedia.provider, |
|
|
venue_id: inputMedia.venue_id |
|
|
}; |
|
|
break; |
|
|
|
|
|
case 'messageMediaPending': |
|
|
media = inputMedia; |
|
|
break; |
|
|
} |
|
|
|
|
|
var flags = 0; |
|
|
var pFlags = {}; |
|
|
if (peerID != fromID) { |
|
|
flags |= 2; |
|
|
pFlags.out = true; |
|
|
if (!AppUsersManager.isBot(peerID)) { |
|
|
flags |= 1; |
|
|
pFlags.unread = true; |
|
|
} |
|
|
} |
|
|
if (replyToMsgID) { |
|
|
flags |= 8; |
|
|
} |
|
|
if (asChannel) { |
|
|
fromID = 0; |
|
|
} else { |
|
|
flags |= 256; |
|
|
} |
|
|
|
|
|
var message = { |
|
|
_: 'message', |
|
|
id: messageID, |
|
|
from_id: fromID, |
|
|
to_id: AppPeersManager.getOutputPeer(peerID), |
|
|
flags: flags, |
|
|
pFlags: pFlags, |
|
|
date: tsNow(true) + ServerTimeManager.serverTimeOffset, |
|
|
message: '', |
|
|
media: media, |
|
|
random_id: randomIDS, |
|
|
reply_to_msg_id: replyToMsgID, |
|
|
via_bot_id: options.viaBotID, |
|
|
reply_markup: options.reply_markup, |
|
|
views: asChannel && 1, |
|
|
pending: true |
|
|
}; |
|
|
|
|
|
var toggleError = function (on) { |
|
|
var historyMessage = messagesForHistory[messageID]; |
|
|
if (on) { |
|
|
message.error = true; |
|
|
if (historyMessage) { |
|
|
historyMessage.error = true; |
|
|
} |
|
|
} else { |
|
|
delete message.error; |
|
|
if (historyMessage) { |
|
|
delete historyMessage.error; |
|
|
} |
|
|
} |
|
|
$rootScope.$broadcast('messages_pending'); |
|
|
} |
|
|
|
|
|
message.send = function () { |
|
|
var flags = 0; |
|
|
if (replyToMsgID) { |
|
|
flags |= 1; |
|
|
} |
|
|
if (asChannel) { |
|
|
flags |= 16; |
|
|
} |
|
|
|
|
|
var sentRequestOptions = {}; |
|
|
if (pendingAfterMsgs[peerID]) { |
|
|
sentRequestOptions.afterMessageID = pendingAfterMsgs[peerID].messageID; |
|
|
} |
|
|
|
|
|
var apiPromise; |
|
|
if (options.viaBotID) { |
|
|
apiPromise = MtpApiManager.invokeApi('messages.sendInlineBotResult', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
random_id: randomID, |
|
|
reply_to_msg_id: AppMessagesIDsManager.getMessageLocalID(replyToMsgID), |
|
|
query_id: options.queryID, |
|
|
id: options.resultID |
|
|
}, sentRequestOptions); |
|
|
} else { |
|
|
apiPromise = MtpApiManager.invokeApi('messages.sendMedia', { |
|
|
flags: flags, |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
media: inputMedia, |
|
|
random_id: randomID, |
|
|
reply_to_msg_id: AppMessagesIDsManager.getMessageLocalID(replyToMsgID) |
|
|
}, sentRequestOptions); |
|
|
} |
|
|
apiPromise.then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
}, function (error) { |
|
|
toggleError(true); |
|
|
})['finally'](function () { |
|
|
if (pendingAfterMsgs[peerID] === sentRequestOptions) { |
|
|
delete pendingAfterMsgs[peerID]; |
|
|
} |
|
|
}); |
|
|
pendingAfterMsgs[peerID] = sentRequestOptions; |
|
|
}; |
|
|
|
|
|
saveMessages([message]); |
|
|
historyStorage.pending.unshift(messageID); |
|
|
$rootScope.$broadcast('history_append', {peerID: peerID, messageID: messageID, my: true}); |
|
|
|
|
|
setZeroTimeout(message.send); |
|
|
|
|
|
pendingByRandomID[randomIDS] = [peerID, messageID]; |
|
|
} |
|
|
|
|
|
function forwardMessages (peerID, mids) { |
|
|
mids = mids.sort(); |
|
|
|
|
|
var flags = 0; |
|
|
var isChannel = AppPeersManager.isChannel(peerID); |
|
|
var isMegagroup = isChannel && AppPeersManager.isMegagroup(peerID); |
|
|
var asChannel = isChannel && !isMegagroup ? true : false; |
|
|
|
|
|
if (asChannel) { |
|
|
flags |= 16; |
|
|
} |
|
|
|
|
|
var splitted = AppMessagesIDsManager.splitMessageIDsByChannels(mids); |
|
|
var promises = []; |
|
|
angular.forEach(splitted.msgIDs, function (msgIDs, channelID) { |
|
|
var len = msgIDs.length; |
|
|
var randomIDs = []; |
|
|
for (var i = 0; i < len; i++) { |
|
|
randomIDs.push([nextRandomInt(0xFFFFFFFF), nextRandomInt(0xFFFFFFFF)]); |
|
|
} |
|
|
var sentRequestOptions = {}; |
|
|
if (pendingAfterMsgs[peerID]) { |
|
|
sentRequestOptions.afterMessageID = pendingAfterMsgs[peerID].messageID; |
|
|
} |
|
|
var promise = MtpApiManager.invokeApi('messages.forwardMessages', { |
|
|
flags: flags, |
|
|
from_peer: AppPeersManager.getInputPeerByID(-channelID), |
|
|
id: msgIDs, |
|
|
random_id: randomIDs, |
|
|
to_peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
}, sentRequestOptions).then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
})['finally'](function () { |
|
|
if (pendingAfterMsgs[peerID] === sentRequestOptions) { |
|
|
delete pendingAfterMsgs[peerID]; |
|
|
} |
|
|
}); |
|
|
pendingAfterMsgs[peerID] = sentRequestOptions; |
|
|
promises.push(promise); |
|
|
}); |
|
|
|
|
|
return $q.all(promises); |
|
|
}; |
|
|
|
|
|
function startBot (botID, chatID, startParam) { |
|
|
var peerID = chatID ? -chatID : botID; |
|
|
if (startParam) { |
|
|
var randomID = bigint(nextRandomInt(0xFFFFFFFF)).shiftLeft(32).add(bigint(nextRandomInt(0xFFFFFFFF))).toString(); |
|
|
|
|
|
return MtpApiManager.invokeApi('messages.startBot', { |
|
|
bot: AppUsersManager.getUserInput(botID), |
|
|
peer: AppPeersManager.getInputPeerByID(peerID), |
|
|
random_id: randomID, |
|
|
start_param: startParam |
|
|
}).then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
}); |
|
|
} |
|
|
|
|
|
if (chatID) { |
|
|
if (AppChatsManager.isChannel(chatID)) { |
|
|
return MtpApiManager.invokeApi('channels.inviteToChannel', { |
|
|
channel: AppChatsManager.getChannelInput(chatID), |
|
|
users: [AppUsersManager.getUserInput(botID)] |
|
|
}).then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
sendText(peerID, '/start@' + bot.username); |
|
|
}, function (error) { |
|
|
if (error && error.type == 'USER_ALREADY_PARTICIPANT') { |
|
|
var bot = AppUsersManager.getUser(botID); |
|
|
sendText(peerID, '/start@' + bot.username); |
|
|
error.handled = true; |
|
|
} |
|
|
}); |
|
|
} else { |
|
|
return MtpApiManager.invokeApi('messages.addChatUser', { |
|
|
chat_id: AppChatsManager.getChatInput(chatID), |
|
|
user_id: AppUsersManager.getUserInput(botID) |
|
|
}).then(function (updates) { |
|
|
ApiUpdatesManager.processUpdateMessage(updates); |
|
|
sendText(peerID, '/start@' + bot.username); |
|
|
}, function (error) { |
|
|
if (error && error.type == 'USER_ALREADY_PARTICIPANT') { |
|
|
var bot = AppUsersManager.getUser(botID); |
|
|
sendText(peerID, '/start@' + bot.username); |
|
|
error.handled = true; |
|
|
} |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
return sendText(peerID, '/start'); |
|
|
} |
|
|
|
|
|
function cancelPendingMessage (randomID) { |
|
|
var pendingData = pendingByRandomID[randomID]; |
|
|
|
|
|
console.log('pending', randomID, pendingData); |
|
|
|
|
|
if (pendingData) { |
|
|
var peerID = pendingData[0], |
|
|
tempID = pendingData[1], |
|
|
historyStorage = historiesStorage[peerID], |
|
|
pos = historyStorage.pending.indexOf(tempID); |
|
|
|
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updateShort', |
|
|
update: { |
|
|
_: 'updateDeleteMessages', |
|
|
messages: [tempID] |
|
|
} |
|
|
}); |
|
|
|
|
|
if (pos != -1) { |
|
|
historyStorage.pending.splice(pos, 1); |
|
|
} |
|
|
|
|
|
delete messagesForHistory[tempID]; |
|
|
delete messagesStorage[tempID]; |
|
|
|
|
|
return true; |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
function finalizePendingMessage(randomID, finalMessage) { |
|
|
var pendingData = pendingByRandomID[randomID]; |
|
|
// console.log('pdata', randomID, pendingData); |
|
|
|
|
|
if (pendingData) { |
|
|
var peerID = pendingData[0], |
|
|
tempID = pendingData[1], |
|
|
historyStorage = historiesStorage[peerID], |
|
|
message, |
|
|
historyMessage; |
|
|
|
|
|
// console.log('pending', randomID, historyStorage.pending); |
|
|
var pos = historyStorage.pending.indexOf(tempID); |
|
|
if (pos != -1) { |
|
|
historyStorage.pending.splice(pos, 1); |
|
|
} |
|
|
|
|
|
if (message = messagesStorage[tempID]) { |
|
|
delete message.pending; |
|
|
delete message.error; |
|
|
delete message.random_id; |
|
|
delete message.send; |
|
|
} |
|
|
|
|
|
if (historyMessage = messagesForHistory[tempID]) { |
|
|
messagesForHistory[finalMessage.mid] = angular.extend(historyMessage, wrapForHistory(finalMessage.mid)); |
|
|
delete historyMessage.pending; |
|
|
delete historyMessage.error; |
|
|
delete historyMessage.random_id; |
|
|
delete historyMessage.send; |
|
|
|
|
|
$rootScope.$broadcast('messages_pending'); |
|
|
} |
|
|
|
|
|
delete messagesForHistory[tempID]; |
|
|
delete messagesStorage[tempID]; |
|
|
|
|
|
return message; |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
function getMessagePeer (message) { |
|
|
var toID = message.to_id && AppPeersManager.getPeerID(message.to_id) || 0; |
|
|
|
|
|
if (toID < 0) { |
|
|
return toID; |
|
|
} else if (message.pFlags && message.pFlags.out || message.flags & 2) { |
|
|
return toID; |
|
|
} |
|
|
return message.from_id; |
|
|
} |
|
|
|
|
|
function wrapForDialog (msgID, dialog) { |
|
|
var useCache = msgID && dialog !== undefined; |
|
|
var unreadCount = dialog && dialog.unread_count; |
|
|
|
|
|
if (useCache && messagesForDialogs[msgID] !== undefined) { |
|
|
delete messagesForDialogs[msgID].typing; |
|
|
messagesForDialogs[msgID].unreadCount = unreadCount; |
|
|
return messagesForDialogs[msgID]; |
|
|
} |
|
|
|
|
|
var message = angular.copy(messagesStorage[msgID]); |
|
|
|
|
|
if (!message || !message.to_id) { |
|
|
if (dialog && dialog.peerID) { |
|
|
message = {_: 'message', to_id: AppPeersManager.getOutputPeer(dialog.peerID), deleted: true, date: tsNow(true), pFlags: {}}; |
|
|
message.deleted = true; |
|
|
} else { |
|
|
return message; |
|
|
} |
|
|
} |
|
|
|
|
|
message.peerID = getMessagePeer(message); |
|
|
message.peerData = AppPeersManager.getPeer(message.peerID); |
|
|
message.peerString = AppPeersManager.getPeerString(message.peerID); |
|
|
message.unreadCount = unreadCount; |
|
|
|
|
|
if (message._ == 'messageService' && message.action.user_id) { |
|
|
message.action.user = AppUsersManager.getUser(message.action.user_id); |
|
|
} |
|
|
|
|
|
if (message.message && message.message.length) { |
|
|
message.richMessage = RichTextProcessor.wrapRichText(message.message.substr(0, 64), {noLinks: true, noLinebreaks: true}); |
|
|
} |
|
|
|
|
|
message.dateText = dateOrTimeFilter(message.date); |
|
|
|
|
|
if (useCache) { |
|
|
message.draft = DraftsManager.getServerDraft(message.peerID); |
|
|
messagesForDialogs[msgID] = message; |
|
|
} |
|
|
|
|
|
return message; |
|
|
} |
|
|
|
|
|
function wrapSingleMessage(msgID) { |
|
|
if (messagesStorage[msgID]) { |
|
|
return wrapForDialog(msgID); |
|
|
} |
|
|
if (needSingleMessages.indexOf(msgID) == -1) { |
|
|
needSingleMessages.push(msgID); |
|
|
if (fetchSingleMessagesTimeout === false) { |
|
|
fetchSingleMessagesTimeout = setTimeout(fetchSingleMessages, 100); |
|
|
} |
|
|
} |
|
|
return {mid: msgID, loading: true}; |
|
|
} |
|
|
|
|
|
function clearDialogCache (msgID) { |
|
|
delete messagesForDialogs[msgID]; |
|
|
} |
|
|
|
|
|
function wrapForHistory (msgID) { |
|
|
if (messagesForHistory[msgID] !== undefined) { |
|
|
return messagesForHistory[msgID]; |
|
|
} |
|
|
|
|
|
var message = angular.copy(messagesStorage[msgID]) || {id: msgID}; |
|
|
|
|
|
if (message.media && message.media.progress !== undefined) { |
|
|
message.media.progress = messagesStorage[msgID].media.progress; |
|
|
} |
|
|
|
|
|
var fromUser = message.from_id && AppUsersManager.getUser(message.from_id); |
|
|
var fromBot = fromUser && fromUser.pFlags.bot && fromUser.username || false; |
|
|
var withBot = (fromBot || |
|
|
message.to_id && ( |
|
|
message.to_id.chat_id || |
|
|
message.to_id.user_id && AppUsersManager.isBot(message.to_id.user_id) |
|
|
) |
|
|
); |
|
|
|
|
|
if (message.media) { |
|
|
if (message.media.caption && |
|
|
message.media.caption.length) { |
|
|
message.media.rCaption = RichTextProcessor.wrapRichText(message.media.caption, { |
|
|
noCommands: !withBot, |
|
|
fromBot: fromBot |
|
|
}); |
|
|
} |
|
|
|
|
|
switch (message.media._) { |
|
|
case 'messageMediaPhoto': |
|
|
message.media.photo = AppPhotosManager.wrapForHistory(message.media.photo.id); |
|
|
break; |
|
|
|
|
|
case 'messageMediaDocument': |
|
|
message.media.document = AppDocsManager.wrapForHistory(message.media.document.id); |
|
|
break; |
|
|
|
|
|
case 'messageMediaGeo': |
|
|
var mapUrl = 'https://maps.google.com/?q=' + message.media.geo['lat'] + ',' + message.media.geo['long']; |
|
|
message.media.mapUrl = $sce.trustAsResourceUrl(mapUrl); |
|
|
break; |
|
|
|
|
|
case 'messageMediaVenue': |
|
|
var mapUrl; |
|
|
if (message.media.provider == 'foursquare' && |
|
|
message.media.venue_id) { |
|
|
mapUrl = 'https://foursquare.com/v/' + encodeURIComponent(message.media.venue_id); |
|
|
} else { |
|
|
mapUrl = 'https://maps.google.com/?q=' + message.media.geo['lat'] + ',' + message.media.geo['long']; |
|
|
} |
|
|
message.media.mapUrl = $sce.trustAsResourceUrl(mapUrl); |
|
|
break; |
|
|
|
|
|
case 'messageMediaContact': |
|
|
message.media.rFullName = RichTextProcessor.wrapRichText( |
|
|
message.media.first_name + ' ' + (message.media.last_name || ''), |
|
|
{noLinks: true, noLinebreaks: true} |
|
|
); |
|
|
break; |
|
|
|
|
|
case 'messageMediaWebPage': |
|
|
if (!message.media.webpage || |
|
|
message.media.webpage._ == 'webPageEmpty') { |
|
|
delete message.media; |
|
|
break; |
|
|
} |
|
|
message.media.webpage = AppWebPagesManager.wrapForHistory(message.media.webpage.id); |
|
|
break; |
|
|
} |
|
|
} |
|
|
else if (message.action) { |
|
|
switch (message.action._) { |
|
|
case 'messageActionChatEditPhoto': |
|
|
case 'messageActionChannelEditPhoto': |
|
|
message.action.photo = AppPhotosManager.wrapForHistory(message.action.photo.id); |
|
|
break; |
|
|
|
|
|
case 'messageActionChatCreate': |
|
|
case 'messageActionChatEditTitle': |
|
|
case 'messageActionChannelCreate': |
|
|
case 'messageActionChannelEditTitle': |
|
|
message.action.rTitle = RichTextProcessor.wrapRichText(message.action.title, {noLinebreaks: true}) || _('chat_title_deleted'); |
|
|
break; |
|
|
|
|
|
case 'messageActionBotIntro': |
|
|
message.action.rDescription = RichTextProcessor.wrapRichText(message.action.description, { |
|
|
noCommands: !withBot, |
|
|
fromBot: fromBot |
|
|
}); |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
var replyToMsgID = message.reply_to_mid; |
|
|
if (replyToMsgID) { |
|
|
message.reply_to_msg = wrapSingleMessage(replyToMsgID); |
|
|
} |
|
|
|
|
|
return messagesForHistory[msgID] = message; |
|
|
} |
|
|
|
|
|
function wrapReplyMarkup (replyMarkup) { |
|
|
if (!replyMarkup || |
|
|
replyMarkup._ == 'replyKeyboardHide') { |
|
|
return false; |
|
|
} |
|
|
if (replyMarkup.wrapped) { |
|
|
return replyMarkup; |
|
|
} |
|
|
var isInline = replyMarkup._ == 'replyInlineMarkup'; |
|
|
var count = replyMarkup.rows && replyMarkup.rows.length || 0; |
|
|
if (!isInline && |
|
|
count > 0 && |
|
|
count <= 4 && |
|
|
!(replyMarkup.pFlags && replyMarkup.pFlags.resize)) { |
|
|
replyMarkup.splitCount = count; |
|
|
} |
|
|
replyMarkup.wrapped = true; |
|
|
angular.forEach(replyMarkup.rows, function (markupRow) { |
|
|
angular.forEach(markupRow.buttons, function (markupButton) { |
|
|
markupButton.rText = RichTextProcessor.wrapRichText(markupButton.text, {noLinks: true, noLinebreaks: true}); |
|
|
if (markupButton._ == 'keyboardButtonUrl') { |
|
|
markupButton.pUrl = RichTextProcessor.wrapUrl(markupButton.url, 1); |
|
|
} |
|
|
}) |
|
|
}); |
|
|
return replyMarkup; |
|
|
} |
|
|
|
|
|
function fetchSingleMessages () { |
|
|
if (fetchSingleMessagesTimeout !== false) { |
|
|
clearTimeout(fetchSingleMessagesTimeout); |
|
|
fetchSingleMessagesTimeout = false; |
|
|
} |
|
|
if (!needSingleMessages.length) { |
|
|
return; |
|
|
} |
|
|
var mids = needSingleMessages.slice(); |
|
|
needSingleMessages = []; |
|
|
|
|
|
var splitted = AppMessagesIDsManager.splitMessageIDsByChannels(mids); |
|
|
angular.forEach(splitted.msgIDs, function (msgIDs, channelID) { |
|
|
var promise; |
|
|
if (channelID > 0) { |
|
|
promise = MtpApiManager.invokeApi('channels.getMessages', { |
|
|
channel: AppChatsManager.getChannelInput(channelID), |
|
|
id: msgIDs |
|
|
}); |
|
|
} else { |
|
|
promise = MtpApiManager.invokeApi('messages.getMessages', { |
|
|
id: msgIDs |
|
|
}); |
|
|
} |
|
|
|
|
|
promise.then(function (getMessagesResult) { |
|
|
AppUsersManager.saveApiUsers(getMessagesResult.users); |
|
|
AppChatsManager.saveApiChats(getMessagesResult.chats); |
|
|
saveMessages(getMessagesResult.messages); |
|
|
|
|
|
$rootScope.$broadcast('messages_downloaded', splitted.mids[channelID]); |
|
|
}) |
|
|
}) |
|
|
} |
|
|
|
|
|
function incrementMessageViews () { |
|
|
if (incrementMessageViewsTimeout !== false) { |
|
|
clearTimeout(incrementMessageViewsTimeout); |
|
|
incrementMessageViewsTimeout = false; |
|
|
} |
|
|
if (!needIncrementMessageViews.length) { |
|
|
return; |
|
|
} |
|
|
var mids = needIncrementMessageViews.slice(); |
|
|
needIncrementMessageViews = []; |
|
|
|
|
|
var splitted = AppMessagesIDsManager.splitMessageIDsByChannels(mids); |
|
|
angular.forEach(splitted.msgIDs, function (msgIDs, channelID) { |
|
|
// console.log('increment', msgIDs, channelID); |
|
|
MtpApiManager.invokeApi('messages.getMessagesViews', { |
|
|
peer: AppPeersManager.getInputPeerByID(-channelID), |
|
|
id: msgIDs, |
|
|
increment: true |
|
|
}).then(function (views) { |
|
|
if (channelID) { |
|
|
var mids = splitted.mids[channelID]; |
|
|
var updates = []; |
|
|
for (var i = 0; i < mids.length; i++) { |
|
|
updates.push({ |
|
|
_: 'updateChannelMessageViews', |
|
|
channel_id: channelID, |
|
|
id: mids[i], |
|
|
views: views[i] |
|
|
}); |
|
|
} |
|
|
ApiUpdatesManager.processUpdateMessage({ |
|
|
_: 'updates', |
|
|
updates: updates, |
|
|
chats: [], |
|
|
users: [] |
|
|
}); |
|
|
} |
|
|
}) |
|
|
}) |
|
|
} |
|
|
|
|
|
function regroupWrappedHistory (history, limit) { |
|
|
if (!history || !history.length) { |
|
|
return false; |
|
|
} |
|
|
var start = 0, |
|
|
len = history.length, |
|
|
end = len, |
|
|
i, curDay, prevDay, curMessage, prevMessage, curGrouped, prevGrouped, |
|
|
wasUpdated = false, |
|
|
groupFwd = !Config.Mobile; |
|
|
|
|
|
if (limit > 0) { |
|
|
end = Math.min(limit, len); |
|
|
} else if (limit < 0) { |
|
|
start = Math.max(0, end + limit); |
|
|
} |
|
|
|
|
|
for (i = start; i < end; i++) { |
|
|
if (history[i].deleted) { |
|
|
history.splice(i, 1); |
|
|
end--; |
|
|
continue; |
|
|
} |
|
|
curMessage = history[i]; |
|
|
curDay = Math.floor((curMessage.date + ServerTimeManager.midnightOffset) / 86400); |
|
|
|
|
|
prevGrouped = prevMessage && prevMessage.grouped; |
|
|
curGrouped = curMessage.grouped; |
|
|
|
|
|
if (curDay === prevDay) { |
|
|
if (curMessage.needDate) { |
|
|
delete curMessage.needDate; |
|
|
wasUpdated = true; |
|
|
} |
|
|
} else if (!i || prevMessage) { |
|
|
if (!curMessage.needDate) { |
|
|
curMessage.needDate = true; |
|
|
wasUpdated = true; |
|
|
} |
|
|
} |
|
|
|
|
|
if (curMessage.fwdFromID && |
|
|
curMessage.media && |
|
|
curMessage.media.document && |
|
|
(curMessage.media.document.sticker || curMessage.media.document.audioTitle) && |
|
|
(curMessage.fromID != (prevMessage || {}).fromID || !(prevMessage || {}).fwdFromID)) { |
|
|
delete curMessage.fwdFromID; |
|
|
curMessage._ = 'message'; |
|
|
} |
|
|
|
|
|
if (curMessage.views && |
|
|
!incrementedMessageViews[curMessage.mid]) { |
|
|
incrementedMessageViews[curMessage.mid] = true; |
|
|
needIncrementMessageViews.push(curMessage.mid); |
|
|
if (incrementMessageViewsTimeout === false) { |
|
|
incrementMessageViewsTimeout = setTimeout(incrementMessageViews, 10000); |
|
|
} |
|
|
} |
|
|
|
|
|
if (prevMessage && |
|
|
// !curMessage.views && |
|
|
prevMessage.fromID == curMessage.fromID && |
|
|
!prevMessage.fwdFromID == !curMessage.fwdFromID && |
|
|
prevMessage.viaBotID == curMessage.viaBotID && |
|
|
!prevMessage.action && |
|
|
!curMessage.action && |
|
|
curMessage.date < prevMessage.date + 900) { |
|
|
|
|
|
var singleLine = curMessage.message && curMessage.message.length < 70 && curMessage.message.indexOf("\n") == -1 && !curMessage.reply_to_mid; |
|
|
if (groupFwd && |
|
|
curMessage.fwdFromID && |
|
|
curMessage.fwdFromID == prevMessage.fwdFromID && |
|
|
curMessage.viaBotID == prevMessage.viaBotID) { |
|
|
curMessage.grouped = singleLine ? 'im_grouped_fwd_short' : 'im_grouped_fwd'; |
|
|
} else { |
|
|
curMessage.grouped = !curMessage.fwdFromID && singleLine ? 'im_grouped_short' : 'im_grouped'; |
|
|
} |
|
|
if (groupFwd && curMessage.fwdFromID) { |
|
|
if (!prevMessage.grouped) { |
|
|
prevMessage.grouped = 'im_grouped_fwd_start'; |
|
|
} |
|
|
if (curMessage.grouped && i == len - 1) { |
|
|
curMessage.grouped += ' im_grouped_fwd_end'; |
|
|
} |
|
|
} |
|
|
} else if (prevMessage || !i) { |
|
|
delete curMessage.grouped; |
|
|
|
|
|
if (groupFwd && prevMessage && prevMessage.grouped && prevMessage.fwdFromID) { |
|
|
prevMessage.grouped += ' im_grouped_fwd_end'; |
|
|
} |
|
|
} |
|
|
if (!wasUpdated && prevGrouped != (prevMessage && prevMessage.grouped)) { |
|
|
wasUpdated = true; |
|
|
} |
|
|
prevMessage = curMessage; |
|
|
prevDay = curDay; |
|
|
} |
|
|
if (!wasUpdated && curGrouped != (prevMessage && prevMessage.grouped)) { |
|
|
wasUpdated = true; |
|
|
} |
|
|
|
|
|
return wasUpdated; |
|
|
} |
|
|
|
|
|
function getMessageThumb (message, thumbWidth, thumbHeight) { |
|
|
var thumbPhotoSize; |
|
|
var sticker = false; |
|
|
if (message.media) { |
|
|
switch (message.media._) { |
|
|
case 'messageMediaPhoto': |
|
|
thumbPhotoSize = AppPhotosManager.choosePhotoSize(message.media.photo, thumbWidth, thumbHeight); |
|
|
break; |
|
|
|
|
|
case 'messageMediaDocument': |
|
|
thumbPhotoSize = message.media.document.thumb; |
|
|
if (message.media.document.sticker) { |
|
|
sticker = true; |
|
|
} |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
if (thumbPhotoSize && thumbPhotoSize._ != 'photoSizeEmpty') { |
|
|
var dim = calcImageInBox(thumbPhotoSize.w, thumbPhotoSize.h, thumbWidth, thumbHeight, true); |
|
|
|
|
|
var thumb = { |
|
|
width: dim.w, |
|
|
height: dim.h, |
|
|
location: thumbPhotoSize.location, |
|
|
size: thumbPhotoSize.size |
|
|
}; |
|
|
if (sticker) { |
|
|
thumb.location.sticker = true; |
|
|
} |
|
|
|
|
|
return thumb; |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
function incrementMaxSeenID (maxID) { |
|
|
if (maxSeenID !== false && maxID && maxID > maxSeenID) { |
|
|
Storage.set({ |
|
|
max_seen_msg: maxID |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
function notifyAboutMessage (message, options) { |
|
|
options = options || {}; |
|
|
|
|
|
var peerID = getMessagePeer(message); |
|
|
var peerString; |
|
|
var notification = {}, |
|
|
notificationMessage = false, |
|
|
notificationPhoto; |
|
|
|
|
|
var notifySettings = NotificationsManager.getNotifySettings(); |
|
|
|
|
|
if (message.fwdFromID && options.fwd_count) { |
|
|
notificationMessage = fwdMessagesPluralize(options.fwd_count); |
|
|
} else if (message.message) { |
|
|
if (notifySettings.nopreview) { |
|
|
notificationMessage = _('conversation_message_sent'); |
|
|
} else { |
|
|
notificationMessage = RichTextProcessor.wrapPlainText(message.message); |
|
|
} |
|
|
} else if (message.media) { |
|
|
switch (message.media._) { |
|
|
case 'messageMediaPhoto': |
|
|
notificationMessage = _('conversation_media_photo_raw'); |
|
|
break; |
|
|
case 'messageMediaDocument': |
|
|
switch (message.media.document.type) { |
|
|
case 'gif': |
|
|
notificationMessage = _('conversation_media_gif_raw'); |
|
|
break; |
|
|
case 'sticker': |
|
|
notificationMessage = _('conversation_media_sticker'); |
|
|
var stickerEmoji = message.media.document.stickerEmojiRaw; |
|
|
if (stickerEmoji !== undefined) { |
|
|
notificationMessage = RichTextProcessor.wrapPlainText(stickerEmoji) + ' ' + notificationMessage; |
|
|
} |
|
|
break; |
|
|
case 'video': |
|
|
notificationMessage = _('conversation_media_video_raw'); |
|
|
break; |
|
|
case 'voice': |
|
|
case 'audio': |
|
|
notificationMessage = _('conversation_media_audio_raw'); |
|
|
break; |
|
|
default: |
|
|
notificationMessage = message.media.document.file_name || _('conversation_media_document_raw'); |
|
|
break; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'messageMediaGeo': |
|
|
case 'messageMediaVenue': |
|
|
notificationMessage = _('conversation_media_location_raw'); |
|
|
break; |
|
|
case 'messageMediaContact': |
|
|
notificationMessage = _('conversation_media_contact_raw'); |
|
|
break; |
|
|
default: |
|
|
notificationMessage = _('conversation_media_attachment_raw'); |
|
|
break; |
|
|
} |
|
|
} else if (message._ == 'messageService') { |
|
|
switch (message.action._) { |
|
|
case 'messageActionChatCreate': |
|
|
notificationMessage = _('conversation_group_created_raw'); |
|
|
break; |
|
|
case 'messageActionChatEditTitle': |
|
|
notificationMessage = _('conversation_group_renamed_raw'); |
|
|
break; |
|
|
case 'messageActionChatEditPhoto': |
|
|
notificationMessage = _('conversation_group_photo_updated_raw'); |
|
|
break; |
|
|
case 'messageActionChatDeletePhoto': |
|
|
notificationMessage = _('conversation_group_photo_removed_raw'); |
|
|
break; |
|
|
case 'messageActionChatAddUser': |
|
|
case 'messageActionChatAddUsers': |
|
|
notificationMessage = _('conversation_invited_user_message_raw'); |
|
|
break; |
|
|
case 'messageActionChatReturn': |
|
|
notificationMessage = _('conversation_returned_to_group_raw'); |
|
|
break; |
|
|
case 'messageActionChatJoined': |
|
|
notificationMessage = _('conversation_joined_group_raw'); |
|
|
break; |
|
|
case 'messageActionChatDeleteUser': |
|
|
notificationMessage = _('conversation_kicked_user_message_raw'); |
|
|
break; |
|
|
case 'messageActionChatLeave': |
|
|
notificationMessage = _('conversation_left_group_raw'); |
|
|
break; |
|
|
case 'messageActionChatJoinedByLink': |
|
|
notificationMessage = _('conversation_joined_by_link_raw'); |
|
|
break; |
|
|
case 'messageActionChannelCreate': |
|
|
notificationMessage = _('conversation_created_channel_raw'); |
|
|
break; |
|
|
case 'messageActionChannelEditTitle': |
|
|
notificationMessage = _('conversation_changed_channel_name_raw'); |
|
|
break; |
|
|
case 'messageActionChannelEditPhoto': |
|
|
notificationMessage = _('conversation_changed_channel_photo_raw'); |
|
|
break; |
|
|
case 'messageActionChannelDeletePhoto': |
|
|
notificationMessage = _('conversation_removed_channel_photo_raw'); |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (peerID > 0) { |
|
|
var fromUser = AppUsersManager.getUser(message.from_id); |
|
|
var fromPhoto = AppUsersManager.getUserPhoto(message.from_id); |
|
|
|
|
|
notification.title = (fromUser.first_name || '') + |
|
|
(fromUser.first_name && fromUser.last_name ? ' ' : '') + |
|
|
(fromUser.last_name || ''); |
|
|
if (!notification.title) { |
|
|
notification.title = fromUser.phone || _('conversation_unknown_user_raw'); |
|
|
} |
|
|
|
|
|
notificationPhoto = fromPhoto; |
|
|
|
|
|
peerString = AppUsersManager.getUserString(peerID); |
|
|
|
|
|
} else { |
|
|
notification.title = AppChatsManager.getChat(-peerID).title || _('conversation_unknown_chat_raw'); |
|
|
|
|
|
if (message.from_id > 0) { |
|
|
var fromUser = AppUsersManager.getUser(message.from_id); |
|
|
notification.title = (fromUser.first_name || fromUser.last_name || _('conversation_unknown_user_raw')) + |
|
|
' @ ' + |
|
|
notification.title; |
|
|
} |
|
|
|
|
|
notificationPhoto = AppChatsManager.getChatPhoto(-peerID); |
|
|
|
|
|
peerString = AppChatsManager.getChatString(-peerID); |
|
|
} |
|
|
|
|
|
notification.title = RichTextProcessor.wrapPlainText(notification.title); |
|
|
|
|
|
notification.onclick = function () { |
|
|
$rootScope.$broadcast('history_focus', { |
|
|
peerString: peerString, |
|
|
messageID: message.flags & 16 ? message.mid : 0, |
|
|
}); |
|
|
}; |
|
|
|
|
|
notification.message = notificationMessage; |
|
|
notification.key = 'msg' + message.mid; |
|
|
notification.tag = peerString; |
|
|
|
|
|
if (notificationPhoto.location && !notificationPhoto.location.empty) { |
|
|
MtpApiFileManager.downloadSmallFile(notificationPhoto.location, notificationPhoto.size).then(function (blob) { |
|
|
if (message.pFlags.unread) { |
|
|
notification.image = blob; |
|
|
NotificationsManager.notify(notification); |
|
|
} |
|
|
}); |
|
|
} else { |
|
|
NotificationsManager.notify(notification); |
|
|
} |
|
|
} |
|
|
|
|
|
var newMessagesHandlePromise = false; |
|
|
var newMessagesToHandle = {}; |
|
|
var newDialogsHandlePromise = false; |
|
|
var newDialogsToHandle = {}; |
|
|
var notificationsHandlePromise = false; |
|
|
var notificationsToHandle = {}; |
|
|
|
|
|
function handleNewMessages () { |
|
|
$timeout.cancel(newMessagesHandlePromise); |
|
|
newMessagesHandlePromise = false; |
|
|
$rootScope.$broadcast('history_multiappend', newMessagesToHandle); |
|
|
newMessagesToHandle = {}; |
|
|
} |
|
|
|
|
|
function handleNewDialogs () { |
|
|
$timeout.cancel(newDialogsHandlePromise); |
|
|
newDialogsHandlePromise = false; |
|
|
angular.forEach(newDialogsToHandle, function (dialog) { |
|
|
pushDialogToStorage(dialog); |
|
|
}); |
|
|
$rootScope.$broadcast('dialogs_multiupdate', newDialogsToHandle); |
|
|
newDialogsToHandle = {}; |
|
|
} |
|
|
|
|
|
function handleNotifications () { |
|
|
$timeout.cancel(notificationsHandlePromise); |
|
|
notificationsHandlePromise = false; |
|
|
|
|
|
var timeout = $rootScope.idle.isIDLE && StatusManager.isOtherDeviceActive() ? 30000 : 1000; |
|
|
angular.forEach(notificationsToHandle, function (notifyPeerToHandle) { |
|
|
notifyPeerToHandle.isMutedPromise.then(function (muted) { |
|
|
var topMessage = notifyPeerToHandle.top_message; |
|
|
if (muted || |
|
|
!topMessage.pFlags.unread) { |
|
|
return; |
|
|
} |
|
|
setTimeout(function () { |
|
|
if (topMessage.pFlags.unread) { |
|
|
notifyAboutMessage(topMessage, { |
|
|
fwd_count: notifyPeerToHandle.fwd_count |
|
|
}); |
|
|
} |
|
|
}, timeout); |
|
|
}); |
|
|
}); |
|
|
|
|
|
notificationsToHandle = {}; |
|
|
} |
|
|
|
|
|
$rootScope.$on('apiUpdate', function (e, update) { |
|
|
// if (update._ != 'updateUserStatus') { |
|
|
// console.log('on apiUpdate', update); |
|
|
// } |
|
|
switch (update._) { |
|
|
case 'updateMessageID': |
|
|
var randomID = update.random_id; |
|
|
var pendingData = pendingByRandomID[randomID]; |
|
|
if (pendingData) { |
|
|
var peerID = pendingData[0]; |
|
|
var channelID = AppPeersManager.isChannel(peerID) ? -peerID : 0; |
|
|
pendingByMessageID[AppMessagesIDsManager.getFullMessageID(update.id, channelID)] = randomID; |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateNewMessage': |
|
|
case 'updateNewChannelMessage': |
|
|
var message = update.message, |
|
|
peerID = getMessagePeer(message), |
|
|
historyStorage = historiesStorage[peerID]; |
|
|
|
|
|
if (update._ == 'updateNewChannelMessage') { |
|
|
var chat = AppChatsManager.getChat(-peerID); |
|
|
if (chat.pFlags && (chat.pFlags.left || chat.pFlags.kicked)) { |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
saveMessages([message], {isNew: true}); |
|
|
|
|
|
if (historyStorage !== undefined) { |
|
|
var history = historyStorage.history; |
|
|
if (history.indexOf(message.mid) != -1) { |
|
|
return false; |
|
|
} |
|
|
var topMsgID = history[0]; |
|
|
history.unshift(message.mid); |
|
|
if (message.mid > 0 && message.mid < topMsgID) { |
|
|
history.sort(function (a, b) { |
|
|
return b - a; |
|
|
}); |
|
|
} |
|
|
if (historyStorage.count !== null) { |
|
|
historyStorage.count++; |
|
|
} |
|
|
} else { |
|
|
historyStorage = historiesStorage[peerID] = { |
|
|
count: null, |
|
|
history: [message.mid], |
|
|
pending: [] |
|
|
}; |
|
|
} |
|
|
|
|
|
if (mergeReplyKeyboard(historyStorage, message)) { |
|
|
$rootScope.$broadcast('history_reply_markup', {peerID: peerID}) |
|
|
} |
|
|
|
|
|
if (!message.pFlags.out && message.from_id) { |
|
|
AppUsersManager.forceUserOnline(message.from_id); |
|
|
} |
|
|
|
|
|
var randomID = pendingByMessageID[message.mid], |
|
|
pendingMessage; |
|
|
|
|
|
if (randomID) { |
|
|
if (pendingMessage = finalizePendingMessage(randomID, message)) { |
|
|
$rootScope.$broadcast('history_update', {peerID: peerID}); |
|
|
} |
|
|
delete pendingByMessageID[message.mid]; |
|
|
} |
|
|
|
|
|
if (!pendingMessage) { |
|
|
if (newMessagesToHandle[peerID] === undefined) { |
|
|
newMessagesToHandle[peerID] = []; |
|
|
} |
|
|
newMessagesToHandle[peerID].push(message.mid); |
|
|
if (!newMessagesHandlePromise) { |
|
|
newMessagesHandlePromise = $timeout(handleNewMessages, 0); |
|
|
} |
|
|
} |
|
|
|
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
var dialog; |
|
|
var inboxUnread = !message.pFlags.out && message.pFlags.unread; |
|
|
|
|
|
if (foundDialog.length) { |
|
|
dialog = foundDialog[0]; |
|
|
dialog.top_message = message.mid; |
|
|
if (inboxUnread) { |
|
|
dialog.unread_count++; |
|
|
} |
|
|
} else { |
|
|
SearchIndexManager.indexObject(peerID, AppPeersManager.getPeerSearchText(peerID), dialogsIndex); |
|
|
dialog = { |
|
|
peerID: peerID, |
|
|
unread_count: inboxUnread ? 1 : 0, |
|
|
top_message: message.mid |
|
|
}; |
|
|
} |
|
|
dialog.index = generateDialogIndex(message.date); |
|
|
|
|
|
newDialogsToHandle[peerID] = dialog; |
|
|
if (!newDialogsHandlePromise) { |
|
|
newDialogsHandlePromise = $timeout(handleNewDialogs, 0); |
|
|
} |
|
|
|
|
|
if (inboxUnread && |
|
|
($rootScope.selectedPeerID != peerID || $rootScope.idle.isIDLE) && |
|
|
!message.pFlags.silent) { |
|
|
|
|
|
var notifyPeer = message.flags & 16 ? message.from_id : peerID; |
|
|
var notifyPeerToHandle = notificationsToHandle[notifyPeer]; |
|
|
if (notifyPeerToHandle === undefined) { |
|
|
notifyPeerToHandle = notificationsToHandle[notifyPeer] = { |
|
|
isMutedPromise: NotificationsManager.getPeerMuted(notifyPeer), |
|
|
fwd_count: 0, |
|
|
from_id: 0 |
|
|
}; |
|
|
} |
|
|
|
|
|
if (notifyPeerToHandle.from_id != message.from_id) { |
|
|
notifyPeerToHandle.from_id = message.from_id; |
|
|
notifyPeerToHandle.fwd_count = 0; |
|
|
} |
|
|
if (message.fwdFromID) { |
|
|
notifyPeerToHandle.fwd_count++; |
|
|
} |
|
|
|
|
|
notifyPeerToHandle.top_message = message; |
|
|
|
|
|
if (!notificationsHandlePromise) { |
|
|
notificationsHandlePromise = $timeout(handleNotifications, 1000); |
|
|
} |
|
|
} |
|
|
|
|
|
incrementMaxSeenID(message.id); |
|
|
break; |
|
|
|
|
|
case 'updateEditMessage': |
|
|
case 'updateEditChannelMessage': |
|
|
var message = update.message; |
|
|
var peerID = getMessagePeer(message); |
|
|
var channelID = message.to_id._ == 'peerChannel' ? -peerID : 0; |
|
|
var mid = AppMessagesIDsManager.getFullMessageID(message.id, channelID); |
|
|
if (messagesStorage[mid] === undefined) { |
|
|
break; |
|
|
} |
|
|
|
|
|
// console.trace(dT(), 'edit message', message); |
|
|
saveMessages([message], {isEdited: true}); |
|
|
safeReplaceObject(messagesStorage[mid], message); |
|
|
|
|
|
var wasForHistory = messagesForHistory[mid]; |
|
|
if (wasForHistory !== undefined) { |
|
|
delete messagesForHistory[mid]; |
|
|
var newForHistory = wrapForHistory(mid); |
|
|
safeReplaceObject(wasForHistory, newForHistory); |
|
|
messagesForHistory[mid] = wasForHistory; |
|
|
} |
|
|
|
|
|
if (message.clear_history) { |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
if (foundDialog[0] && |
|
|
foundDialog[0].top_message == mid) { |
|
|
$rootScope.$broadcast('dialog_flush', {peerID: peerID}); |
|
|
} else { |
|
|
$rootScope.$broadcast('history_delete', {peerID: peerID, msgs: [mid]}); |
|
|
} |
|
|
} else { |
|
|
$rootScope.$broadcast('message_edit', { |
|
|
peerID: peerID, |
|
|
id: message.id, |
|
|
mid: mid |
|
|
}); |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateReadHistoryInbox': |
|
|
case 'updateReadHistoryOutbox': |
|
|
case 'updateReadChannelInbox': |
|
|
case 'updateReadChannelOutbox': |
|
|
var isOut = update._ == 'updateReadHistoryOutbox' || update._ == 'updateReadChannelOutbox'; |
|
|
var channelID = update.channel_id; |
|
|
var maxID = AppMessagesIDsManager.getFullMessageID(update.max_id, channelID); |
|
|
var peerID = channelID ? -channelID : AppPeersManager.getPeerID(update.peer); |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
var history = (historiesStorage[peerID] || {}).history || []; |
|
|
var newUnreadCount = false; |
|
|
var length = history.length; |
|
|
var foundAffected = false; |
|
|
var messageID, message, i; |
|
|
|
|
|
if (peerID > 0 && isOut) { |
|
|
AppUsersManager.forceUserOnline(peerID); |
|
|
} |
|
|
|
|
|
for (i = 0; i < length; i++) { |
|
|
messageID = history[i]; |
|
|
if (messageID > maxID) { |
|
|
continue; |
|
|
} |
|
|
message = messagesStorage[messageID]; |
|
|
|
|
|
if (message.pFlags.out != isOut) { |
|
|
continue; |
|
|
} |
|
|
if (!message.pFlags.unread) { |
|
|
break; |
|
|
} |
|
|
// console.log('read', messageID, message.pFlags.unread, message); |
|
|
if (message && message.pFlags.unread) { |
|
|
message.pFlags.unread = false; |
|
|
if (messagesForHistory[messageID]) { |
|
|
messagesForHistory[messageID].pFlags.unread = false; |
|
|
if (!foundAffected) { |
|
|
foundAffected = true; |
|
|
} |
|
|
} |
|
|
if (messagesForDialogs[messageID]) { |
|
|
messagesForDialogs[messageID].pFlags.unread = false; |
|
|
} |
|
|
if (!message.pFlags.out) { |
|
|
if (foundDialog[0]) { |
|
|
newUnreadCount = --foundDialog[0].unread_count; |
|
|
} |
|
|
NotificationsManager.cancel('msg' + messageID); |
|
|
} |
|
|
} |
|
|
} |
|
|
if (foundDialog[0]) { |
|
|
if (!isOut && |
|
|
newUnreadCount && |
|
|
foundDialog[0].top_message <= maxID) { |
|
|
newUnreadCount = foundDialog[0].unread_count = 0; |
|
|
} |
|
|
var dialogKey = isOut ? 'read_outbox_max_id' : 'read_inbox_max_id'; |
|
|
foundDialog[0][dialogKey] = maxID; |
|
|
} |
|
|
|
|
|
if (newUnreadCount !== false) { |
|
|
$rootScope.$broadcast('dialog_unread', {peerID: peerID, count: newUnreadCount}); |
|
|
} |
|
|
if (foundAffected) { |
|
|
$rootScope.$broadcast('messages_read'); |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateReadMessagesContents': |
|
|
var messages = update.messages; |
|
|
var len = messages.length; |
|
|
var i, messageID, message, historyMessage; |
|
|
for (i = 0; i < len; i++) { |
|
|
messageID = messages[i]; |
|
|
if (message = messagesStorage[messageID]) { |
|
|
delete message.pFlags.media_unread; |
|
|
} |
|
|
if (historyMessage = messagesForHistory[messageID]) { |
|
|
delete historyMessage.pFlags.media_unread; |
|
|
} |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateDeleteMessages': |
|
|
case 'updateDeleteChannelMessages': |
|
|
var dialogsUpdated = {}; |
|
|
var historiesUpdated = {}; |
|
|
var channelID = update.channel_id; |
|
|
var messageID, message, i, peerID, foundDialog, history; |
|
|
var peerMessagesToHandle, peerMessagesHandlePos; |
|
|
|
|
|
for (i = 0; i < update.messages.length; i++) { |
|
|
messageID = AppMessagesIDsManager.getFullMessageID(update.messages[i], channelID); |
|
|
message = messagesStorage[messageID]; |
|
|
if (message) { |
|
|
peerID = getMessagePeer(message); |
|
|
history = historiesUpdated[peerID] || (historiesUpdated[peerID] = {count: 0, unread: 0, msgs: {}}); |
|
|
|
|
|
if (!message.pFlags.out && message.pFlags.unread) { |
|
|
history.unread++; |
|
|
NotificationsManager.cancel('msg' + messageID); |
|
|
} |
|
|
history.count++; |
|
|
history.msgs[messageID] = true; |
|
|
|
|
|
if (messagesForHistory[messageID]) { |
|
|
messagesForHistory[messageID].deleted = true; |
|
|
delete messagesForHistory[messageID]; |
|
|
} |
|
|
if (messagesForDialogs[messageID]) { |
|
|
messagesForDialogs[messageID].deleted = true; |
|
|
delete messagesForDialogs[messageID]; |
|
|
} |
|
|
message.deleted = true; |
|
|
messagesStorage[messageID] = { |
|
|
deleted: true, |
|
|
id: messageID, |
|
|
from_id: message.from_id, |
|
|
to_id: message.to_id, |
|
|
flags: message.flags, |
|
|
pFlags: message.pFlags, |
|
|
date: message.date |
|
|
}; |
|
|
|
|
|
peerMessagesToHandle = newMessagesToHandle[peerID]; |
|
|
if (peerMessagesToHandle && peerMessagesToHandle.length) { |
|
|
peerMessagesHandlePos = peerMessagesToHandle.indexOf(messageID); |
|
|
if (peerMessagesHandlePos != -1) { |
|
|
peerMessagesToHandle.splice(peerMessagesHandlePos); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
angular.forEach(historiesUpdated, function (updatedData, peerID) { |
|
|
var historyStorage = historiesStorage[peerID]; |
|
|
if (historyStorage !== undefined) { |
|
|
var newHistory = [], |
|
|
newPending = []; |
|
|
for (var i = 0; i < historyStorage.history.length; i++) { |
|
|
if (!updatedData.msgs[historyStorage.history[i]]) { |
|
|
newHistory.push(historyStorage.history[i]); |
|
|
} |
|
|
} |
|
|
historyStorage.history = newHistory; |
|
|
if (updatedData.count && |
|
|
historyStorage.count !== null && |
|
|
historyStorage.count > 0) { |
|
|
historyStorage.count -= updatedData.count; |
|
|
if (historyStorage.count < 0) { |
|
|
historyStorage.count = 0; |
|
|
} |
|
|
} |
|
|
|
|
|
for (var i = 0; i < historyStorage.pending.length; i++) { |
|
|
if (!updatedData.msgs[historyStorage.pending[i]]) { |
|
|
newPending.push(historyStorage.pending[i]); |
|
|
} |
|
|
} |
|
|
historyStorage.pending = newPending; |
|
|
|
|
|
$rootScope.$broadcast('history_delete', {peerID: peerID, msgs: updatedData.msgs}); |
|
|
} |
|
|
|
|
|
var foundDialog = getDialogByPeerID(peerID)[0]; |
|
|
if (foundDialog) { |
|
|
if (updatedData.unread) { |
|
|
foundDialog.unread_count -= updatedData.unread; |
|
|
|
|
|
$rootScope.$broadcast('dialog_unread', { |
|
|
peerID: peerID, |
|
|
count: foundDialog.unread_count |
|
|
}); |
|
|
} |
|
|
|
|
|
if (updatedData.msgs[foundDialog.top_message]) { |
|
|
reloadConversation(peerID); |
|
|
} |
|
|
} |
|
|
}); |
|
|
break; |
|
|
|
|
|
case 'updateChannel': |
|
|
var channelID = update.channel_id; |
|
|
var peerID = -channelID; |
|
|
var channel = AppChatsManager.getChat(channelID); |
|
|
|
|
|
var needDialog = channel._ == 'channel' && (!channel.pFlags.left && !channel.pFlags.kicked); |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
var hasDialog = foundDialog.length > 0; |
|
|
|
|
|
var canViewHistory = channel._ == 'channel' && (channel.username || !channel.pFlags.left && !channel.pFlags.kicked) && true || false; |
|
|
var hasHistory = historiesStorage[peerID] !== undefined; |
|
|
|
|
|
if (canViewHistory != hasHistory) { |
|
|
delete historiesStorage[peerID]; |
|
|
$rootScope.$broadcast('history_forbidden', peerID); |
|
|
} |
|
|
if (hasDialog != needDialog) { |
|
|
if (needDialog) { |
|
|
reloadConversation(-channelID); |
|
|
} else { |
|
|
if (foundDialog[0]) { |
|
|
dialogsStorage.dialogs.splice(foundDialog[1], 1); |
|
|
$rootScope.$broadcast('dialog_drop', {peerID: peerID}); |
|
|
} |
|
|
} |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateChannelReload': |
|
|
var channelID = update.channel_id; |
|
|
var peerID = -channelID; |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
if (foundDialog[0]) { |
|
|
dialogsStorage.dialogs.splice(foundDialog[1], 1); |
|
|
} |
|
|
delete historiesStorage[peerID]; |
|
|
reloadConversation(-channelID).then(function () { |
|
|
$rootScope.$broadcast('history_reload', peerID); |
|
|
}); |
|
|
break; |
|
|
|
|
|
case 'updateChannelMessageViews': |
|
|
var views = update.views; |
|
|
var mid = AppMessagesIDsManager.getFullMessageID(update.id, update.channel_id); |
|
|
var message = getMessage(mid); |
|
|
if (message && message.views && message.views < views) { |
|
|
message.views = views; |
|
|
$rootScope.$broadcast('message_views', { |
|
|
mid: mid, |
|
|
views: views |
|
|
}); |
|
|
} |
|
|
break; |
|
|
|
|
|
case 'updateDraftMessage': |
|
|
var peerID = AppPeersManager.getPeerID(update.peer); |
|
|
var draft = DraftsManager.saveDraft(peerID, update.draft); |
|
|
|
|
|
var dialog = getDialogByPeerID(peerID)[0]; |
|
|
if (dialog) { |
|
|
if (dialog && draft && draft.date) { |
|
|
dialog.index = generateDialogIndex(draft.date); |
|
|
pushDialogToStorage(dialog); |
|
|
} |
|
|
$rootScope.$broadcast('dialog_draft', { |
|
|
peerID: peerID, |
|
|
draft: draft |
|
|
}); |
|
|
} |
|
|
break; |
|
|
} |
|
|
}); |
|
|
|
|
|
function reloadConversation (peerID) { |
|
|
return MtpApiManager.invokeApi('messages.getPeerDialogs', { |
|
|
peers: [ |
|
|
AppPeersManager.getInputPeerByID(peerID) |
|
|
] |
|
|
}).then(function (dialogsResult) { |
|
|
AppUsersManager.saveApiUsers(dialogsResult.users); |
|
|
AppChatsManager.saveApiChats(dialogsResult.chats); |
|
|
saveMessages(dialogsResult.messages); |
|
|
|
|
|
var updatedDialogs = {}; |
|
|
var hasUpdated = false; |
|
|
angular.forEach(dialogsResult.dialogs, function (dialog) { |
|
|
if (dialog.top_message) { |
|
|
saveConversation(dialog); |
|
|
if (getDialogByPeerID(dialog.peerID).length) { |
|
|
$rootScope.$broadcast('dialog_top', dialog); |
|
|
} else { |
|
|
updatedDialogs[dialog.peerID] = dialog; |
|
|
hasUpdated = true; |
|
|
} |
|
|
} else { |
|
|
var peerID = AppPeersManager.getPeerID(dialog.peer); |
|
|
var foundDialog = getDialogByPeerID(peerID); |
|
|
if (foundDialog.length) { |
|
|
dialogsStorage.dialogs.splice(foundDialog[1], 1); |
|
|
$rootScope.$broadcast('dialog_drop', {peerID: peerID}); |
|
|
} |
|
|
} |
|
|
}); |
|
|
if (hasUpdated) { |
|
|
$rootScope.$broadcast('dialogs_multiupdate', updatedDialogs); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
$rootScope.$on('webpage_updated', function (e, eventData) { |
|
|
angular.forEach(eventData.msgs, function (msgID) { |
|
|
var historyMessage = messagesForHistory[msgID]; |
|
|
if (historyMessage) { |
|
|
historyMessage.media = { |
|
|
_: 'messageMediaWebPage', |
|
|
webpage: AppWebPagesManager.wrapForHistory(eventData.id) |
|
|
}; |
|
|
$rootScope.$broadcast('message_edit', { |
|
|
peerID: getMessagePeer(historyMessage), |
|
|
id: historyMessage.id, |
|
|
mid: msgID, |
|
|
justMedia: true |
|
|
}); |
|
|
} |
|
|
}) |
|
|
}); |
|
|
|
|
|
$rootScope.$on('draft_updated', function (e, eventData) { |
|
|
var peerID = eventData.peerID; |
|
|
var draft = eventData.draft; |
|
|
|
|
|
var dialog = getDialogByPeerID(peerID)[0]; |
|
|
if (dialog) { |
|
|
if (dialog && draft && draft.date) { |
|
|
dialog.index = generateDialogIndex(draft.date); |
|
|
pushDialogToStorage(dialog); |
|
|
} |
|
|
} |
|
|
}); |
|
|
|
|
|
return { |
|
|
getConversations: getConversations, |
|
|
getHistory: getHistory, |
|
|
getSearch: getSearch, |
|
|
getMessage: getMessage, |
|
|
getReplyKeyboard: getReplyKeyboard, |
|
|
readHistory: readHistory, |
|
|
readMessages: readMessages, |
|
|
flushHistory: flushHistory, |
|
|
deleteMessages: deleteMessages, |
|
|
sendText: sendText, |
|
|
sendFile: sendFile, |
|
|
sendOther: sendOther, |
|
|
forwardMessages: forwardMessages, |
|
|
startBot: startBot, |
|
|
convertMigratedPeer: convertMigratedPeer, |
|
|
getMessagePeer: getMessagePeer, |
|
|
getMessageThumb: getMessageThumb, |
|
|
getMessageShareLink: getMessageShareLink, |
|
|
clearDialogCache: clearDialogCache, |
|
|
wrapForDialog: wrapForDialog, |
|
|
wrapForHistory: wrapForHistory, |
|
|
wrapReplyMarkup: wrapReplyMarkup, |
|
|
wrapSingleMessage: wrapSingleMessage, |
|
|
regroupWrappedHistory: regroupWrappedHistory |
|
|
} |
|
|
}) |
|
|
|
|
|
.service('AppMessagesIDsManager', function () { |
|
|
var channelLocals = {}; |
|
|
var channelsByLocals = {}; |
|
|
var channelCurLocal = 0; |
|
|
var fullMsgIDModulus = 4294967296; |
|
|
|
|
|
return { |
|
|
getFullMessageID: getFullMessageID, |
|
|
getMessageIDInfo: getMessageIDInfo, |
|
|
getMessageLocalID: getMessageLocalID, |
|
|
splitMessageIDsByChannels: splitMessageIDsByChannels, |
|
|
} |
|
|
|
|
|
function getFullMessageID (msgID, channelID) { |
|
|
if (!channelID || msgID <= 0) { |
|
|
return msgID; |
|
|
} |
|
|
msgID = getMessageLocalID(msgID); |
|
|
var localStart = channelLocals[channelID]; |
|
|
if (!localStart) { |
|
|
localStart = (++channelCurLocal) * fullMsgIDModulus; |
|
|
channelsByLocals[localStart] = channelID; |
|
|
channelLocals[channelID] = localStart; |
|
|
} |
|
|
|
|
|
return localStart + msgID; |
|
|
} |
|
|
|
|
|
function getMessageIDInfo (fullMsgID) { |
|
|
if (fullMsgID < fullMsgIDModulus) { |
|
|
return [fullMsgID, 0]; |
|
|
} |
|
|
var msgID = fullMsgID % fullMsgIDModulus; |
|
|
var channelID = channelsByLocals[fullMsgID - msgID]; |
|
|
|
|
|
return [msgID, channelID]; |
|
|
} |
|
|
|
|
|
function getMessageLocalID (fullMsgID) { |
|
|
if (!fullMsgID) { |
|
|
return 0; |
|
|
} |
|
|
return fullMsgID % fullMsgIDModulus; |
|
|
} |
|
|
|
|
|
function splitMessageIDsByChannels (mids) { |
|
|
var msgIDsByChannels = {}; |
|
|
var midsByChannels = {}; |
|
|
var i, mid, msgChannel, channelID; |
|
|
for (i = 0; i < mids.length; i++) { |
|
|
mid = mids[i]; |
|
|
msgChannel = getMessageIDInfo(mid); |
|
|
channelID = msgChannel[1]; |
|
|
if (msgIDsByChannels[channelID] === undefined) { |
|
|
msgIDsByChannels[channelID] = []; |
|
|
midsByChannels[channelID] = []; |
|
|
} |
|
|
msgIDsByChannels[channelID].push(msgChannel[0]); |
|
|
midsByChannels[channelID].push(mid); |
|
|
} |
|
|
|
|
|
return { |
|
|
msgIDs: msgIDsByChannels, |
|
|
mids: midsByChannels |
|
|
}; |
|
|
} |
|
|
})
|
|
|
|
