public override async Task RemoveAndClearDialog()
{
try {
await ClearDialogHistory();
if (dialog.peer.Constructor == Constructor.peerChat)
{
InputPeer peer = InputPeer;
InputPeerChatConstructor peerChat = (InputPeerChatConstructor)peer;
InputUser user = TL.inputUserSelf();
messages_StatedMessage message =
await session.Api.messages_deleteChatUser(peerChat.chat_id, user);
switch (message.Constructor)
{
case Constructor.messages_statedMessage:
session.Updates.processUpdatePtsSeq(((Messages_statedMessageConstructor)message).pts, ((Messages_statedMessageConstructor)message).seq);
break;
case Constructor.messages_statedMessageLink:
session.Updates.processUpdatePtsSeq(((Messages_statedMessageLinkConstructor)message).pts, ((Messages_statedMessageLinkConstructor)message).seq);
break;
}
}
session.Dialogs.Model.Dialogs.Remove(this);
}
catch (Exception ex) {
logger.error("exception: {0}", ex);
}
}
public override void OnResponse(BinaryReader reader)
{
var code = reader.ReadUInt32();
if (code != 0xd07ae726 && code != 0xa9af2881)
throw new InvalidOperationException($"Expected Tl messages_StatedMessage type");
StatedMessage = TL.Parse<messages_StatedMessage>(reader);
}
public override void OnResponse(BinaryReader reader)
{
var code = reader.ReadUInt32();
if (code != 0xd07ae726 && code != 0xa9af2881)
{
throw new InvalidOperationException($"Expected Tl messages_StatedMessage type");
}
StatedMessage = TL.Parse <messages_StatedMessage>(reader);
}
public void Process(messages_StatedMessage statedMessage)
{
switch (statedMessage.Constructor)
{
case Constructor.messages_statedMessage:
Process((Messages_statedMessageConstructor)statedMessage);
break;
case Constructor.messages_statedMessageLink:
Process((Messages_statedMessageLinkConstructor)statedMessage);
break;
}
}
private async Task DoCreateChat() {
List<InputUser> inputUsers = new List<InputUser>();
ObservableCollection<UserModel> users = SelectableUsers.GetUsers();
foreach (var userModel in users) {
if (userModel.IsCheckedInternal)
inputUsers.Add(TL.inputUserContact(userModel.Id));
}
messages_StatedMessage msg = await TelegramSession.Instance.Api.messages_createChat(inputUsers, ChatTitleEdit.ContentText.Text);
TelegramSession.Instance.Updates.Process(msg);
foreach (var userModel in SelectableUsers.GetUsers()) {
userModel.IsCheckedInternal = false;
}
}
private async Task DoForwardMessages(InputPeer peer)
{
if (messageId.Count == 1)
{
messages_StatedMessage msg = await TelegramSession.Instance.Api.messages_forwardMessage(peer, messageId.First(),
Helpers.GenerateRandomLong());
TelegramSession.Instance.Updates.Process(msg);
}
else
{
messages_StatedMessages msgs = await TelegramSession.Instance.Api.messages_forwardMessages(peer, messageId);
TelegramSession.Instance.Updates.Process(msgs);
}
}
public async Task SendMedia(InputMedia media)
{
try {
long randomId = Helpers.GenerateRandomLong();
// PHOTO IS HERE
MessageModelUndelivered undeliveredMessage = new MessageModelUndelivered()
{
MessageType = MessageModelUndelivered.Type.Text,
Text = "",
Timestamp = DateTime.Now,
RandomId = randomId
};
ProcessNewMessage(undeliveredMessage);
messages_StatedMessage sentMessage =
await session.Api.messages_sendMedia(InputPeer, media, randomId);
Message message;
int pts, seq;
if (sentMessage.Constructor == Constructor.messages_statedMessage)
{
Messages_statedMessageConstructor sentMessageConstructor =
(Messages_statedMessageConstructor)sentMessage;
session.Updates.ProcessChats(sentMessageConstructor.chats);
session.Updates.ProcessUsers(sentMessageConstructor.users);
pts = sentMessageConstructor.pts;
seq = sentMessageConstructor.seq;
message = sentMessageConstructor.message;
}
else if (sentMessage.Constructor == Constructor.messages_statedMessageLink)
{
Messages_statedMessageLinkConstructor statedMessageLink =
(Messages_statedMessageLinkConstructor)sentMessage;
session.Updates.ProcessChats(statedMessageLink.chats);
session.Updates.ProcessUsers(statedMessageLink.users);
// TODO: process links
pts = statedMessageLink.pts;
seq = statedMessageLink.seq;
message = statedMessageLink.message;
}
else
{
logger.error("unknown messages_StatedMessage constructor");
return;
}
if (!session.Updates.processUpdatePtsSeq(pts, seq))
{
logger.error("send media process updates failed");
messages.Remove(undeliveredMessage);
return;
}
TelegramSession.Instance.Dialogs.Model.UpDialog(this);
int messageIndex = messages.IndexOf(undeliveredMessage);
if (messageIndex != -1)
{
MessageModel messageModel = new MessageModelDelivered(message);
MessageModelDelivered newMessage = (MessageModelDelivered)messageModel;
var selectedMessages = from msg in messages
where msg is MessageModelDelivered && ((MessageModelDelivered)msg).Id == messageModel.Id
select msg;
if (selectedMessages.Any())
{
messages.RemoveAt(messageIndex);
}
else
{
messages[messageIndex] =
new MessageModelDelivered(message);
}
}
else
{
logger.error("not found undelivered message to confirmation");
}
}
catch (Exception ex) {
logger.error("Error sending media {0}", ex);
}
}
public void Process(messages_StatedMessage statedMessage) {
switch(statedMessage.Constructor) {
case Constructor.messages_statedMessage:
Process((Messages_statedMessageConstructor)statedMessage);
break;
case Constructor.messages_statedMessageLink:
Process((Messages_statedMessageLinkConstructor)statedMessage);
break;
}
}
