From 8589b99e4ff2b2ed48bf71236507d83e260da711 Mon Sep 17 00:00:00 2001
From: overtake <overtakeful@gmail.com>
Date: Tue, 15 Aug 2017 15:01:02 +0300
Subject: [PATCH] no message

---
 TelegramCore/Holes.swift                      |  6 ++--
 .../ManagedAutoremoveMessageOperations.swift  |  2 +-
 TelegramCore/SearchMessages.swift             | 34 ++++++++++++++-----
 3 files changed, 31 insertions(+), 11 deletions(-)

diff --git a/TelegramCore/Holes.swift b/TelegramCore/Holes.swift
index 80f8c54599..7247ceadb0 100644
--- a/TelegramCore/Holes.swift
+++ b/TelegramCore/Holes.swift
@@ -39,9 +39,11 @@ func fetchMessageHistoryHole(network: Network, postbox: Postbox, hole: MessageHi
                         case .UpperToLower:
                             break
                         case .LowerToUpper:
-                            assertionFailure(".LowerToUpper not supported")
+                         //   assertionFailure(".LowerToUpper not supported")
+                        break
                         case .AroundIndex:
-                            assertionFailure(".AroundIndex not supported")
+                           // assertionFailure(".AroundIndex not supported")
+                        break
                     }
                     //request = network.request(Api.functions.messages.search(flags: 0, peer: inputPeer, q: "", filter: filter, minDate: 0, maxDate: hole.maxIndex.timestamp, offset: 0, maxId: hole.maxIndex.id.id + 1, limit: Int32(limit)))
                     request = network.request(Api.functions.messages.search(flags: 0, peer: inputPeer, q: "", fromId: nil, filter: filter, minDate: 0, maxDate: hole.maxIndex.timestamp, offset: 0, maxId: Int32.max, limit: Int32(limit)))
diff --git a/TelegramCore/ManagedAutoremoveMessageOperations.swift b/TelegramCore/ManagedAutoremoveMessageOperations.swift
index bcfd00c01f..d487248841 100644
--- a/TelegramCore/ManagedAutoremoveMessageOperations.swift
+++ b/TelegramCore/ManagedAutoremoveMessageOperations.swift
@@ -65,7 +65,7 @@ func managedAutoremoveMessageOperations(postbox: Postbox) -> Signal<Void, NoErro
                     |> delay(max(0.0, Double(entry.timestamp) - timestamp), queue: Queue.concurrentDefaultQueue())
                     |> then(postbox.modify { modifier -> Void in
                         if let message = modifier.getMessage(entry.messageId) {
-                            if message.id.namespace == Namespaces.Peer.SecretChat {
+                            if message.id.peerId.namespace == Namespaces.Peer.SecretChat {
                                 modifier.deleteMessages([entry.messageId])
                             } else {
                                 modifier.updateMessage(message.id, update: { currentMessage in
diff --git a/TelegramCore/SearchMessages.swift b/TelegramCore/SearchMessages.swift
index fc40af43e6..2affb77a50 100644
--- a/TelegramCore/SearchMessages.swift
+++ b/TelegramCore/SearchMessages.swift
@@ -9,13 +9,13 @@ import Foundation
     import MtProtoKitDynamic
 #endif
 
-public func searchMessages(account: Account, peerId: PeerId?, query: String, tagMask: MessageTags? = nil) -> Signal<[Message], NoError> {
+public func searchMessages(account: Account, peerId: PeerId?, query: String, fromId:PeerId? = nil, tagMask: MessageTags? = nil) -> Signal<[Message], NoError> {
     if let peerId = peerId, peerId.namespace == Namespaces.Peer.SecretChat {
         return account.postbox.modify { modifier -> [Message] in
             return modifier.searchMessages(peerId: peerId, query: query, tags: tagMask)
         }
     } else {
-        let searchResult: Signal<Api.messages.Messages, NoError>
+        let searchResult: Signal<Api.messages.Messages?, NoError>
         
         let filter: Api.MessagesFilter
 
@@ -34,22 +34,40 @@ public func searchMessages(account: Account, peerId: PeerId?, query: String, tag
         }
         
         if let peerId = peerId {
-            searchResult = account.postbox.loadedPeerWithId(peerId)
-                |> mapToSignal { peer -> Signal<Api.messages.Messages, NoError> in
-                    if let inputPeer = apiInputPeer(peer) {
-                        return account.network.request(Api.functions.messages.search(flags: 0, peer: inputPeer, q: query, fromId: nil, filter: filter, minDate: 0, maxDate: Int32.max - 1, offset: 0, maxId: Int32.max - 1, limit: 64))
-                            |> retryRequest
+            searchResult = account.postbox.modify { modifier -> (peer:Peer?, from: Peer?) in
+                if let fromId = fromId {
+                    return (peer: modifier.getPeer(peerId), from: modifier.getPeer(fromId))
+                }
+                return (peer: modifier.getPeer(peerId), from: nil)
+            } |> mapToSignal { values -> Signal<Api.messages.Messages?, NoError> in
+                    if let peer = values.peer, let inputPeer = apiInputPeer(peer) {
+                        var fromInputUser:Api.InputUser? = nil
+                        var flags:Int32 = 0
+                        if let from = values.from {
+                            fromInputUser = apiInputUser(from)
+                            if let _ = fromInputUser {
+                                flags |= (1 << 0)
+                            }
+                        }
+                        return account.network.request(Api.functions.messages.search(flags: flags, peer: inputPeer, q: query, fromId: fromInputUser, filter: filter, minDate: 0, maxDate: Int32.max - 1, offset: 0, maxId: Int32.max - 1, limit: 64))
+                            |> map {Optional($0)}
+                            |> `catch` { _ -> Signal<Api.messages.Messages?, MTRpcError> in
+                                return .single(nil)
+                            } |> mapError {_ in}
                     } else {
                         return .never()
                     }
                 }
         } else {
             searchResult = account.network.request(Api.functions.messages.searchGlobal(q: query, offsetDate: 0, offsetPeer: Api.InputPeer.inputPeerEmpty, offsetId: 0, limit: 64))
-                |> retryRequest
+                |> mapError {_ in} |> map {Optional($0)}
         }
         
         let processedSearchResult = searchResult
             |> mapToSignal { result -> Signal<[Message], NoError> in
+                guard let result = result else {
+                    return .single([])
+                }
                 let messages: [Api.Message]
                 let chats: [Api.Chat]
                 let users: [Api.User]