public async Task AddUserToContactsAsync(UserInfoDto model)
{
if (string.IsNullOrWhiteSpace(model.Login))
{
throw new ArgumentException("Login can't be empty");
}
if (!Regex.Match(model.Login, phoneNumberPattern).Success)
{
throw new ArgumentException("Login is not a valid phone number: " + model.Login);
}
// this is because the contacts in the address come without the "+" prefix
var normalizedNumber = model.Login.StartsWith("+") ?
model.Login.Substring(1, model.Login.Length - 1) :
model.Login;
if (string.IsNullOrWhiteSpace(model.FirstName))
{
throw new ArgumentException("First name can't be empty");
}
if (string.IsNullOrWhiteSpace(model.LastName))
{
throw new ArgumentException("Last name can't be empty");
}
TLVector <TLInputPhoneContact> contacts = new TLVector <TLInputPhoneContact>
{
new TLInputPhoneContact()
{
Phone = normalizedNumber, FirstName = model.FirstName, LastName = model.LastName
}
};
var request = new TLRequestImportContacts()
{
Contacts = contacts
};
await client.SendRequestAsync <TLImportedContacts>(request);
Contacts = await client.GetContactsAsync(); // Updating saved contacts
}
/// <summary>
/// Necesarios: NumeroDestino, Imagen, DescripcionImagen si se quiere
/// </summary>
/// <param name="nuevo"></param>
/// <returns></returns>
public async Task <Respuestas> EnviarImagen(Mensaje nuevo)
{
Respuestas respuesta = new Respuestas();
try
{
var numeroformateado = nuevo.NumeroDestino.StartsWith("+") ?
nuevo.NumeroDestino.Substring(1) :
nuevo.NumeroDestino;
contexto = Iniciar();
await contexto.ConnectAsync();
var contactos = new TLContacts();
contactos = await contexto.GetContactsAsync();
var usuariodestino = contactos.Users.OfType <TLUser>().FirstOrDefault(x => x.Phone == numeroformateado);
if (usuariodestino == null)
{
respuesta.MESSAGE = "El numero" + numeroformateado + " no esta en la lista de sus contactos";
respuesta.STATUS = false;
return(respuesta);
}
MemoryStream imagen = new MemoryStream(Convert.FromBase64String(nuevo.Imagen));
//var im = Image.FromStream(imagen);
//Image imagen_redimensionada = ResizeImage(im, 300, 60);
//args.Image = imagen_redimensionada;
StreamReader imageStream = new StreamReader(imagen); //verificar encoding
var archivo = new TLInputFile();
archivo = (TLInputFile)await contexto.UploadFile("Image" + (new Random().Next()) + ".jpg", imageStream);
if (archivo != null)
{
await contexto.SendUploadedPhoto(new TLInputPeerUser()
{
UserId = usuariodestino.Id
}, archivo, nuevo.DescripcionImagen);
respuesta.MESSAGE = "Imagen enviada a: " + numeroformateado;
respuesta.STATUS = true;
return(respuesta);
}
else
{
respuesta.MESSAGE = "No se pudo enviar imagen, ERROR INTERNO...";
respuesta.STATUS = false;
return(respuesta);
}
}
catch (Exception e)
{
respuesta.MESSAGE = " no se pudo enviar imagen..." + e.Message;
respuesta.STATUS = false;
return(respuesta);
}
}
private async Task <IEnumerable <TelegramContactResponse> > GetContactsAsync(TelegramClient client)
{
_logger.LogDebug("Getting the contacts.");
var contacts = await client.GetContactsAsync();
return(contacts?.Users
.OfType <TLUser>()
.Select(user => BuildTelegramResponse(user)) ?? new List <TelegramContactResponse>());
}
public async Task <TLContacts> GetContactAsync(TelegramClient client)
{
try
{
return(await client.GetContactsAsync());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private async void enviarMensaje(Stream tmp)
{
if (client.IsUserAuthorized())
{
var result = await client.GetContactsAsync();
var user = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Phone == "34" + u.Telefono);
bool enviar = true;
if (user == null)
{
var phoneContact = new TLInputPhoneContact()
{
Phone = "34" + u.Telefono, FirstName = u.Nombre, LastName = u.Apellidos
};
var contacts = new List <TLInputPhoneContact>()
{
phoneContact
};
var req = new TLRequestImportContacts()
{
Contacts = new TLVector <TLInputPhoneContact>(contacts)
};
var rrr = await client.SendRequestAsync <TLImportedContacts>(req);
if (rrr.Imported.Count == 1)
{
user = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Phone == "34" + u.Telefono);
}
else
{
enviar = false;
}
}
if (enviar && user != null)
{
var fileResult = await client.UploadFile(Strings.Factura + i.Mes + "/" + i.Año, new StreamReader(tmp));
TLDocumentAttributeFilename name = new TLDocumentAttributeFilename();
name.FileName = Strings.Factura + i.Mes + "/" + i.Año + ".pdf";
await client.SendUploadedDocument(new TLInputPeerUser()
{
UserId = user.Id
}, fileResult, "", "application/pdf", new TLVector <TLAbsDocumentAttribute>() { name });
}
}
}
private async void button3_Click(object sender, EventArgs e)
{
try
{
var result = await client.GetContactsAsync();
var myInClause = new string[] { "989352185069", "+989352185069", "09352185069" };
var user = result.Users.ToList()
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => myInClause.Contains(x.Phone));
await client.SendMessageAsync(new TLInputPeerUser()
{
UserId = user.Id
}, txtMessage.Text);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public virtual async Task SendMessageByUserNameTest()
{
this.UserNameToSendMessage = ConfigurationManager.AppSettings[nameof(this.UserNameToSendMessage)];
if (string.IsNullOrWhiteSpace(this.UserNameToSendMessage))
{
throw new Exception($"Please fill the '{nameof(this.UserNameToSendMessage)}' setting in app.config file first");
}
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TeleSharp.TL.Contacts.TLFound result = await client.SearchUserAsync(this.UserNameToSendMessage);
TLUser user = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.OfType <TLUser>()
.FirstOrDefault(x => x.Username == this.UserNameToSendMessage.TrimStart('@'));
if (user == null)
{
TeleSharp.TL.Contacts.TLContacts contacts = await client.GetContactsAsync();
user = contacts.Users
.Where(x => x.GetType() == typeof(TLUser))
.OfType <TLUser>()
.FirstOrDefault(x => x.Username == this.UserNameToSendMessage.TrimStart('@'));
}
if (user == null)
{
throw new System.Exception("Username was not found: " + this.UserNameToSendMessage);
}
await client.SendTypingAsync(new TLInputPeerUser()
{
UserId = user.Id
});
Thread.Sleep(3000);
await client.SendMessageAsync(new TLInputPeerUser()
{
UserId = user.Id
}, "TEST");
}
public async Task SendMessage(string message, string userphone)
{
var result = await client.GetContactsAsync();
//find recipient in contacts
var user1 = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Phone == userphone);
//send message
await client.SendMessageAsync(new TLInputPeerUser()
{
UserId = user1.Id
}, message);
}
/// <summary>
/// Sending a message using the recipient's nickname and message text
/// </summary>
/// <param name="recepientUserName"></param>
/// <param name="message"></param>
/// <returns></returns>
public async static Task SendMessage(string recepientUserName, string message)
{
//get user contacts
TLContacts constacts = await _client.GetContactsAsync();
//find recipient in contacts
TLUser user = constacts.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Username == recepientUserName);
//send message
_client.SendMessageAsync(new TLInputPeerUser()
{
UserId = user.Id
}, message);
}
public virtual async Task DownloadFileFromContactTest()
{
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TeleSharp.TL.Contacts.TLContacts result = await client.GetContactsAsync();
TLUser user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == this.NumberToSendMessage);
TLInputPeerUser inputPeer = new TLInputPeerUser()
{
UserId = user.Id
};
TLMessagesSlice res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
Peer = inputPeer
});
TLDocument document = res.Messages
.OfType <TLMessage>()
.Where(m => m.Media != null)
.Select(m => m.Media)
.OfType <TLMessageMediaDocument>()
.Select(md => md.Document)
.OfType <TLDocument>()
.First();
TeleSharp.TL.Upload.TLFile resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
AccessHash = document.AccessHash,
Id = document.Id,
Version = document.Version
},
document.Size);
Assert.IsTrue(resFile.Bytes.Length > 0);
}
/// <summary>
/// This method requests an Authoritzation code to telegram, the user must input then.
/// </summary>
/// <param name="phoneNumber">Phone To send the code</param>
/// <returns></returns>
public async Task Authenticate(String phoneNumber)
{
var hash = await client.SendCodeRequestAsync(phoneNumber);
//Request Code
var code = await Console.In.ReadLineAsync();
//Input code
var user = await client.MakeAuthAsync(phoneNumber, hash, code);
//Request Authoritzation with the code
//get available contacts
Contacts = await client.GetContactsAsync();
}
public virtual async Task SendMessageTest()
{
this.NumberToSendMessage = ConfigurationManager.AppSettings[nameof(this.NumberToSendMessage)];
if (string.IsNullOrWhiteSpace(this.NumberToSendMessage))
{
throw new Exception($"Please fill the '{nameof(this.NumberToSendMessage)}' setting in app.config file first");
}
// this is because the contacts in the address come without the "+" prefix
string normalizedNumber = this.NumberToSendMessage.StartsWith("+") ?
this.NumberToSendMessage.Substring(1, this.NumberToSendMessage.Length - 1) :
this.NumberToSendMessage;
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TeleSharp.TL.Contacts.TLContacts result = await client.GetContactsAsync();
TLUser user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == normalizedNumber);
if (user == null)
{
throw new System.Exception("Number was not found in Contacts List of user: "******"TEST");
}
private async void button2_Click(object sender, EventArgs e)
{
await client.MakeAuthAsync(phone, hash, codeTxt.Text);
var result = await client.GetContactsAsync();
Contacts = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>().ToList();
Contacts.ForEach(user =>
{
listBox1.Items.Add(user.first_name + " " + user.last_name);
});
groupBox1.Text = "Contacts (0/" + listBox1.Items.Count + ")";
button3.Enabled = true;
button1.Enabled = mobileTxt.Enabled = false;
}
static async void a()
{
var store = new FileSessionStore();
var client = new TelegramClient(apiId, apiHash, store, "session");// or C:\\Temp\\mySession
await client.ConnectAsync();
if (!client.IsUserAuthorized())
{
var hash = await client.SendCodeRequestAsync(phoneNumber); //отсылаем запрос на создании сессии
var code = Console.ReadLine(); // код который придет от Telegram
var user = await client.MakeAuthAsync(phoneNumber, hash, code); // создаем сессию
}
//var userByPhoneId = await client.("791812312323"); // импорт по номеру телефона
//var userByUserNameId = await await client.ImportByUserName("userName"); // импорт по юзернейму
var s = await client.IsPhoneRegisteredAsync("xxxxxxxxxxx");//WHO WRITE//WHO WRITE
var f = await client.GetContactsAsync();
Console.WriteLine("контакты");
f.contacts.lists.ForEach(_ => { Console.WriteLine(_.user_id); });
TeleSharp.TL.Contacts.TLRequestImportContacts requestImportContacts = new TeleSharp.TL.Contacts.TLRequestImportContacts();
requestImportContacts.contacts = new TLVector <TLInputPhoneContact>();
requestImportContacts.contacts.lists.Add(new TLInputPhoneContact()
{
phone = "xxxxxxxxxxx",//WHO WRITE//WHO WRITE//WHO WRITE//WHO WRITE//WHO WRITE?
first_name = "",
last_name = ""
});
var o = await client.SendRequestAsync <TeleSharp.TL.Contacts.TLImportedContacts>((TLMethod)requestImportContacts);
var NewUserId = (o.users.lists.First() as TLUser).id;
var d = await client.SendMessageAsync(new TLInputPeerUser()
{
user_id = NewUserId
}, "text xxx");
//return true;
}
static void Main(string[] args)
{
var store = new FileSessionStore();
var asaf = "972528356489";
var m = "972543143131";
var hash = "54a578ab2c70e02c22";
int apiId = 121845;
string apiHash = "888c93f37abef8dde1b7a1cf40580ebb";
var client = new TelegramClient(apiId, apiHash, store);
client.ConnectAsync().Wait();
var estaRegistrado = client.IsPhoneRegisteredAsync("972546252491").Result;
if (estaRegistrado)
{
if (!client.IsUserAuthorized())
{
{
hash = client.SendCodeRequestAsync("972546252491").Result;
// var code = "63811"; // you can change code in debugger
Console.WriteLine("Codigo recibido:");
var strCodigo = Console.ReadLine();
var user = client.MakeAuthAsync("972546252491", hash, strCodigo).Result;
}
}
//send message
//get available contacts
var result = client.GetContactsAsync().Result;
//find recipient in contacts
var userd = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Phone == m);
client.SendMessageAsync(new TLInputPeerUser()
{
UserId = userd.Id
}, "test").Wait();
}
}
public virtual async Task DownloadFileFromContactTest()
{
var client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
var result = await client.GetContactsAsync();
var user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == NumberToSendMessage);
var inputPeer = new TLInputPeerUser()
{
UserId = user.Id
};
var res = await client.SendRequestAsync <TLMessagesSlice>(new TLRequestGetHistory()
{
Peer = inputPeer
});
var document = res.Messages
.OfType <TLMessage>()
.Where(m => m.Media != null)
.Select(m => m.Media)
.OfType <TLMessageMediaDocument>()
.Select(md => md.Document)
.OfType <TLDocument>()
.First();
var resFile = await client.GetFile(
new TLInputDocumentFileLocation()
{
AccessHash = document.AccessHash,
Id = document.Id,
Version = document.Version
},
document.Size);
Assert.IsTrue(resFile.Bytes.Length > 0);
}
private async Task <int> SendTelegram(string message)
{
try
{
var client = new TelegramClient(57982, "19706860344842eadeb0cc00f28d0902");
await client.ConnectAsync();
var hash = await client.SendCodeRequestAsync(this.txtBoxPhone.Text.Trim());
var code = this.txtBoxTelegramCode.Text.Trim(); // you can change code in debugger
var user = await client.MakeAuthAsync(this.txtBoxPhone.Text.Trim(), hash, code);
//get available contacts
var result = await client.GetContactsAsync();
//find recipient in contacts
var recipient = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.phone == this.txtBoxPhone.Text.Trim());
//send message
await client.SendMessageAsync(new TLInputPeerUser()
{
user_id = recipient.id
}, message);
}
catch (Exception ex)
{
var st = new StackTrace(ex, true);
var frame = st.GetFrame(0);
var line = frame.GetFileLineNumber();
// --- Report on error and continue
emailHelper.SendExceptionEmail(ex.Message + " " + line);
}
return(1);
}
public async Task Enviartelegram(EnviarTelegramDto dto)
{
var apiId = 92426;
var apiHash = "77135e73f47f49813618b53e8c51ee89";
var client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
var user = await client.MakeAuthAsync("+5565992291443", dto.Hash, dto.Code);
var result = await client.GetContactsAsync();
//find recipient in contacts
var userR = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.phone == "5565981250768");
//send message
await client.SendMessageAsync(new TLInputPeerUser()
{
user_id = userR.id
}, dto.Mensagem);
}
public IEnumerable <TLADialog> GetContacts()
{
var contacts = AsyncHelpers.RunSync <TLContacts>(() => m_client.GetContactsAsync());
foreach (var absUser in contacts.users.lists)
{
if (absUser.GetType() == typeof(TLUser))
{
var user = (TLUser)absUser;
yield return(new TLADialog()
{
Id = user.id,
Type = TLADialogType.User,
Title = user.first_name + ' ' + user.last_name,
Closed = false
});
}
else
{
throw new TLCoreException("Type of TLDialog is unknown");
}
}
}
public async Task SendMessageTest()
{
var client = new TelegramClient(apiId, apiHash);
await client.ConnectAsync();
var result = await client.GetContactsAsync();
var user = result.users.lists
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.phone == NumberToSendMessage);
await client.SendTypingAsync(new TLInputPeerUser()
{
user_id = user.id
});
Thread.Sleep(3000);
await client.SendMessageAsync(new TLInputPeerUser()
{
user_id = user.id
}, "TEST");
}
public virtual async Task SendPhotoToContactTest()
{
TelegramClient client = this.NewClient();
TelegramAuthModel authModel = new TelegramAuthModel()
{
ApiId = this.ApiId,
ApiHash = this.ApiHash
};
await client.AuthenticateAsync(authModel);
TeleSharp.TL.Contacts.TLContacts result = await client.GetContactsAsync();
TLUser user = result.Users
.OfType <TLUser>()
.FirstOrDefault(x => x.Phone == this.NumberToSendMessage);
TLInputFile fileResult = (TLInputFile)await client.UploadFile("cat.jpg", new StreamReader("data/cat.jpg"));
await client.SendUploadedPhoto(new TLInputPeerUser()
{
UserId = user.Id
}, fileResult, "kitty");
}
private static async Task GetContacts(TelegramClient client)
{
Console.WriteLine("3. Trying to get top 10 contacts ...");
// get available contacts
var result = await client.GetContactsAsync();
//find recipient in contacts
var users = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.Take(10);
//.FirstOrDefault(x => x.phone == "<recipient_phone>");
//send message
foreach (var item in users)
{
Console.WriteLine($" {item.FirstName} {item.LastName} {item.Phone}");
}
Console.WriteLine("3. Trying to get contacts [Done]!");
Console.WriteLine();
}
public Task <TLSchema.Contacts.TLContacts> GetAllContacts()
{
return(telegramClient.GetContactsAsync());
}
private static async Task RunClient(string fileName, string caption)
{
Console.WriteLine("Logging in");
var client = new TelegramClient(_config.ApiId, _config.ApiHash);
await client.ConnectAsync();
TLUser me;
if (!client.IsUserAuthorized())
{
string hash = await client.SendCodeRequestAsync(_config.Number);
Console.Write("Please enter the code you received: ");
string code = Console.ReadLine();
try
{
me = await client.MakeAuthAsync(_config.Number, hash, code);
}
catch (CloudPasswordNeededException)
{
var passwordSetting = await client.GetPasswordSetting();
Console.Write("Enter your 2FA password: "******"CodeToAuthenticate is wrong in the app.config file, fill it with the code you just got now by SMS/Telegram",
ex);
}
catch (Exception ex)
{
Console.WriteLine("An exception occured: " + ex);
Console.WriteLine("If you want a fresh start just remove session.dat file and restart.");
return;
}
}
else
{
var result = await client.GetContactsAsync();
//find recipient in contacts
me = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Self);
}
Console.WriteLine("Uploading file");
var attr = new TLVector <TLAbsDocumentAttribute>();
var docAttr = new TLDocumentAttributeFilename
{
FileName = Path.GetFileName(fileName)
};
attr.Add(docAttr);
var fileResult = await client.UploadFile(Path.GetFileName(fileName), new StreamReader(fileName));
Console.WriteLine("Uploaded; Sending file");
await client.SendUploadedDocument(
new TLInputPeerUser { UserId = me.Id },
fileResult,
caption,
"application/octet-stream",
attr);
Console.WriteLine("Done");
}
internal async Task <TLContacts> GetContactsAsync() => await _client.GetContactsAsync();
static async Task runAsync(string[] args)
{
var config = System.IO.File.ReadAllLines("client.config");
var connectionInfo = new ConnectionInfo(config[2],
config[3],
new PasswordAuthenticationMethod(config[3], config[4]));
var sshClient = new SshClient(connectionInfo);
var sshCommand = config[5];
var client = new TelegramClient(int.Parse(config[0]), config[1]);
await client.ConnectAsync();
if (!client.IsUserAuthorized())
{
Console.WriteLine("Please enter your phone number");
var number = Console.ReadLine();
var hash = await client.SendCodeRequestAsync(number);
Console.WriteLine("Enter the code you recieved from Telegram");
var code = Console.ReadLine();
TLUser user = null;
try
{
user = await client.MakeAuthAsync(number, hash, code);
}
catch (CloudPasswordNeededException)
{
var password = await client.GetPasswordSetting();
Console.WriteLine("Enter your 2FA Password");
var password_str = Console.ReadLine();
user = await client.MakeAuthWithPasswordAsync(password, password_str);
}
}
var result = await client.GetContactsAsync();
var userToSendTo = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Username == "browny99");
var logPeer = new TLInputPeerUser()
{
UserId = userToSendTo.Id
};
await client.SendMessageAsync(logPeer, "Started monitoring");
string UserNameToSendMessage = "@corgigroupagreebot";
var unameResult = await client.SearchUserAsync(UserNameToSendMessage);
var userByName = unameResult.Users
.Where(x => x.GetType() == typeof(TLUser))
.OfType <TLUser>()
.FirstOrDefault(x => x.Username == UserNameToSendMessage.TrimStart('@'));
int retryCounter = 0;
while (!System.IO.File.Exists("cancel.wjdummy"))
{
try
{
TLInputPeerUser botToCheck = new TLInputPeerUser()
{
UserId = userByName.Id, AccessHash = (long)userByName.AccessHash
};
await client.SendMessageAsync(botToCheck, "/start");
await Task.Delay(TimeSpan.FromSeconds(30));
TLAbsMessages history = await client.GetHistoryAsync(botToCheck, limit : 1);
TLMessagesSlice slice = (TLMessagesSlice)history;
var message = ((TLMessage)slice.Messages.ElementAt(0));
if (message.Out == false && message.Message.StartsWith("Hey, good to see you again"))
{
var request = new TLRequestReadHistory();
request.Peer = botToCheck;
await client.SendRequestAsync <TLAffectedMessages>(request);
retryCounter = 0;
}
else
{
retryCounter++;
await client.SendMessageAsync(logPeer, "30 sec unresponsive");
}
if (retryCounter > 5)
{
sshClient.Connect();
var res = sshClient.CreateCommand(sshCommand).Execute();
sshClient.Disconnect();
await client.SendMessageAsync(logPeer, "Restarted server\n\n" + res);
await Task.Delay(TimeSpan.FromSeconds(90));
retryCounter = 0;
}
} catch (Exception e)
{
try
{
await client.SendMessageAsync(logPeer, "Error: \n" + e.ToString());
} catch (Exception ex)
{
Console.WriteLine($"ERROR\n\n{e}\n{ex}\n\nENDERROR");
return;
}
}
}
}
public async Task <Respuestas> AutenticarUsuario(string codigo, string filepath)
{
try
{
Respuestas respuesta = new Respuestas();
contexto = Iniciar();
TLContacts contactos = new TLContacts();
info = CargarDeArchivo <Informacion_sesion>(filepath);
info.Codigo_autenticacion = codigo;
TLUser usuario = null;
await contexto.ConnectAsync();
if (contexto.IsConnected)
{
usuario = await contexto.MakeAuthAsync(info.NumeroPropietario, info.Codigo_solicitud, info.Codigo_autenticacion);
if (usuario != null)
{
info.NombreUsuario = usuario.FirstName;
contactos = await contexto.GetContactsAsync();
List <Usuarios> lista = new List <Usuarios>();
foreach (var item in contactos.Users.OfType <TLUser>())
{
var contacto = new Usuarios
{
Nombre = item.FirstName + " " + item.LastName,
Telefono = "+" + item.Phone
};
lista.Add(contacto);
}
info.contactos = lista.OrderBy(x => x.Nombre).ToList();
JObject objeto = JObject.Parse(File.ReadAllText(filepath.Replace("Registros.txt", "Sesion.txt")));
info.Expiracion.Add(DateTime.Now.AddMilliseconds(objeto.Value <double>("SessionExpires")).ToString("MM/dd/yy H:mm:ss"));
GuardarArchivo(filepath, info);
respuesta.STATUS = true;
respuesta.MESSAGE = "Autenticación exitosa...";
respuesta.data = info;
return(respuesta);
}
else
{
respuesta.MESSAGE = "no se pudo obtener datos de usuario...";
respuesta.STATUS = false;
return(respuesta);
}
}
else
{
respuesta.MESSAGE = "ya se encuentra autenticado...";
respuesta.STATUS = false;
contexto.Dispose();
return(respuesta);
}
}
catch (Exception e)
{
return(new Respuestas()
{
STATUS = false, MESSAGE = "No se pudo autenticar usuario" + e.InnerException.Message
});
}
}
private async void button1_Click(object sender, EventArgs e)
{
if (client.IsUserAuthorized())
{
//сообщение
string message = textBox1.Text;
//получатель
string recipient = textBox2.Text;
//подключаемся
await client.ConnectAsync();
//выбираем список контактов отправителя
var result = await client.GetContactsAsync();
//создаем список контактов
TLUser user = new TLUser();
if (string.IsNullOrWhiteSpace(recipient))
{
MessageBox.Show("Введите телефон получателя!", "Ошибка!");
}
else
{
//выбираем пользователя по номеру телефона из списка контактов
user = result.Users
.Where(x => x.GetType() == typeof(TLUser))
.Cast <TLUser>()
.FirstOrDefault(x => x.Phone == textBox2.Text);
}
if (string.IsNullOrWhiteSpace(message))
{
MessageBox.Show("введите сообщение!", "Ошибка!");
}
else
{
try
{
//отправляем сообщение
await client.SendMessageAsync(new TLInputPeerUser()
{
UserId = user.Id
}, message);
textBox1.Text = "";
}
catch (Exception ex)
{
MessageBox.Show("Данного номера нет в вашем списке контактов!");
}
}
}
else
{
//создаем сессию
var store = new FileSessionStore();
//подключаемся к телеграм
await client.ConnectAsync();
//отправляем код потверждения на наш номер
var hash = await client.SendCodeRequestAsync("79807545992");
//следует поменять на код присланный телеграмом в дебаге
var code = "46222";
//потверждаем нашу учетную запись
var user = await client.MakeAuthAsync("79807545992", hash, code);
}
}
private static async Task CallExportContacts()
{
try
{
if (!TClient.IsUserAuthorized())
{
Console.WriteLine("You are not authenticated, please authenticate first.");
return;
}
Console.WriteLine($"Reading contacts...");
var contacts = (await TClient.GetContactsAsync()) as TLContacts;
Console.WriteLine($"Number of contacts: {contacts.users.lists.Count}");
var fileName = $"ExportedContacts\\Exported-{DateTime.Now.ToString("yyyy-MM-dd HH-mm.ss")}.vcf";
var fileNameWihContacts = $"ExportedContacts\\Exported-WithPhoto-{DateTime.Now.ToString("yyyy-MM-dd HH-mm.ss")}.vcf";
Directory.CreateDirectory("ExportedContacts");
Console.Write($"Don't export contacts without phone? [y/n] ");
var filterResult = Console.ReadLine() ?? "";
var dontExport = filterResult == "" || filterResult.ToLower() == "y";
Console.WriteLine($"Writing to: {fileName}");
using (var file = File.Create(fileName))
using (var stringWrite = new StreamWriter(file))
{
var savedCount = 0;
foreach (var user in contacts.users.lists.OfType <TLUser>())
{
if (dontExport)
{
if (string.IsNullOrWhiteSpace(user.phone))
{
continue;
}
}
//vCard Begin
stringWrite.WriteLine("BEGIN:VCARD");
stringWrite.WriteLine("VERSION:2.1");
//Name
stringWrite.WriteLine("N:" + user.last_name + ";" + user.first_name);
//Full Name
stringWrite.WriteLine("FN:" + user.first_name + " " +
/* nameMiddle + " " +*/ user.last_name);
stringWrite.WriteLine("TEL;CELL:" + ConvertFromTelegramPhoneNumber(user.phone));
//vCard End
stringWrite.WriteLine("END:VCARD");
savedCount++;
}
Console.WriteLine($"Total number of contacts saved: {savedCount}");
Console.WriteLine();
}
Console.Write($"Do you want to export contacts with images? [y=enter/n] ");
var exportWithImagesResult = Console.ReadLine() ?? "";
var exportWithImages = exportWithImagesResult == "" || exportWithImagesResult.ToLower() == "y";
if (exportWithImages)
{
Console.Write($"Save small or big images? [s=small=enter/b=big] ");
var saveSmallResult = Console.ReadLine() ?? "";
var saveSmallImages = saveSmallResult == "" || saveSmallResult.ToLower() == "s";
Console.WriteLine($"Writing to: {fileNameWihContacts}");
using (var file = File.Create(fileNameWihContacts))
using (var stringWrite = new StreamWriter(file))
{
var savedCount = 0;
foreach (var user in contacts.users.lists.OfType <TLUser>())
{
if (dontExport)
{
if (string.IsNullOrWhiteSpace(user.phone))
{
continue;
}
}
string userPhotoString = null;
try
{
var userPhoto = user.photo as TLUserProfilePhoto;
if (userPhoto != null)
{
var photo = userPhoto.photo_big as TLFileLocation;
if (saveSmallImages)
{
photo = userPhoto.photo_small as TLFileLocation;
}
if (photo != null)
{
Console.Write($"Reading prfile image for: {user.first_name} {user.last_name}...");
var fileResult = await TClient.GetFile(new TLInputFileLocation()
{
local_id = photo.local_id,
secret = photo.secret,
volume_id = photo.volume_id
},
filePartSize : -1);
var smallPhotoBytes = fileResult.bytes;
// resize if it is the big image
if (!saveSmallImages)
{
Console.Write("Resizing...");
smallPhotoBytes = ResizeProfileImage(ref smallPhotoBytes);
}
userPhotoString = Convert.ToBase64String(smallPhotoBytes);
Console.WriteLine("Done");
}
}
}
catch (Exception e)
{
Console.WriteLine("Failed due " + e.Message);
}
//System.IO.StringWriter stringWrite = new System.IO.StringWriter();
//create an htmltextwriter which uses the stringwriter
//vCard Begin
stringWrite.WriteLine("BEGIN:VCARD");
stringWrite.WriteLine("VERSION:2.1");
//Name
stringWrite.WriteLine("N:" + user.last_name + ";" + user.first_name);
//Full Name
stringWrite.WriteLine("FN:" + user.first_name + " " +
/* nameMiddle + " " +*/ user.last_name);
stringWrite.WriteLine("TEL;CELL:" + ConvertFromTelegramPhoneNumber(user.phone));
if (userPhotoString != null)
{
stringWrite.WriteLine("PHOTO;ENCODING=BASE64;TYPE=JPEG:");
stringWrite.WriteLine(userPhotoString);
stringWrite.WriteLine(string.Empty);
}
//vCard End
stringWrite.WriteLine("END:VCARD");
savedCount++;
}
Console.WriteLine($"Total number of contacts with images saved: {savedCount}");
Console.WriteLine();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
}
private static async Task CallExportContacts()
{
try
{
if (!_client.IsUserAuthorized())
{
Console.WriteLine("You are not authenticated, please authenticate first.");
return;
}
Console.WriteLine($"Reading contacts...");
var contacts = (await _client.GetContactsAsync()) as TLContacts;
Console.WriteLine($"Number of contacts: {contacts.Users.Count}");
var fileName = $"ExportedContacts\\Exported-{DateTime.Now:yyyy-MM-dd HH-mm.ss}.vcf";
var fileNameWihContacts = $"ExportedContacts\\Exported-WithPhoto-{DateTime.Now:yyyy-MM-dd HH-mm.ss}.vcf";
Directory.CreateDirectory("ExportedContacts");
Console.Write($"Export contacts without phone? [y/n] ");
var filterResult = Console.ReadLine() ?? "";
var dontExport = !(filterResult == "" || filterResult.ToLower() == "n");
var usersList = contacts.Users.OfType <TLUser>().ToList();
Console.WriteLine($"Writing to: {fileName}");
using (var file = File.Create(fileName))
using (var stringWrite = new StreamWriter(file))
{
var savedCount = 0;
foreach (var user in usersList)
{
if (dontExport)
{
if (string.IsNullOrWhiteSpace(user.Phone))
{
continue;
}
}
//vCard Begin
stringWrite.WriteLine("BEGIN:VCARD");
stringWrite.WriteLine("VERSION:2.1");
//Name
stringWrite.WriteLine("N:" + user.LastName + ";" + user.FirstName);
//Full Name
stringWrite.WriteLine("FN:" + user.FirstName + " " +
/* nameMiddle + " " +*/ user.LastName);
stringWrite.WriteLine("TEL;CELL:" + ConvertFromTelegramPhoneNumber(user.Phone));
//vCard End
stringWrite.WriteLine("END:VCARD");
savedCount++;
}
Console.WriteLine($"Total number of contacts saved: {savedCount}");
Console.WriteLine();
}
Console.Write($"Do you want to export contacts with images? [y=enter/n] ");
var exportWithImagesResult = Console.ReadLine() ?? "";
var exportWithImages = exportWithImagesResult == "" || exportWithImagesResult.ToLower() == "y";
if (exportWithImages)
{
Console.Write($"Save small or big images? [s=small=enter/b=big] ");
var saveSmallResult = Console.ReadLine() ?? "";
var saveSmallImages = saveSmallResult == "" || saveSmallResult.ToLower() == "s";
Console.WriteLine($"Writing to: {fileNameWihContacts}");
using (var file = File.Create(fileNameWihContacts))
using (var stringWrite = new StreamWriter(file))
{
var savedCount = 0;
foreach (var user in usersList)
{
if (dontExport)
{
if (string.IsNullOrWhiteSpace(user.Phone))
{
continue;
}
}
string userPhotoString = null;
try
{
var userPhoto = user.Photo as TLUserProfilePhoto;
if (userPhoto != null)
{
var photo = userPhoto.PhotoBig as TLFileLocation;
if (saveSmallImages)
{
photo = userPhoto.PhotoSmall as TLFileLocation;
}
if (photo != null)
{
var displayName = user.FirstName + " " + user.LastName;
if (string.IsNullOrWhiteSpace(displayName))
{
displayName = user.Username;
}
Console.Write($"Reading prfile image for: {displayName}...");
var smallPhotoBytes = await GetFile(_client,
new TLInputFileLocation()
{
LocalId = photo.LocalId,
Secret = photo.Secret,
VolumeId = photo.VolumeId
});
// resize if it is the big image
if (!saveSmallImages)
{
Console.Write("Resizing...");
smallPhotoBytes = ResizeProfileImage(ref smallPhotoBytes);
}
userPhotoString = Convert.ToBase64String(smallPhotoBytes);
Console.WriteLine("Done");
}
}
}
catch (Exception e)
{
Console.WriteLine("Failed due " + e.Message);
}
//System.IO.StringWriter stringWrite = new System.IO.StringWriter();
//create an htmltextwriter which uses the stringwriter
//vCard Begin
stringWrite.WriteLine("BEGIN:VCARD");
stringWrite.WriteLine("VERSION:2.1");
//Name
if (string.IsNullOrEmpty(user.LastName) && string.IsNullOrEmpty(user.FirstName))
{
stringWrite.WriteLine("N:" + user.Username + ";");
}
else
{
stringWrite.WriteLine("N:" + user.LastName + ";" + user.FirstName);
}
//Full Name
stringWrite.WriteLine("FN:" + user.FirstName + " " +
/* nameMiddle + " " +*/ user.LastName);
stringWrite.WriteLine("TEL;CELL:" + ConvertFromTelegramPhoneNumber(user.Phone));
if (userPhotoString != null)
{
stringWrite.WriteLine("PHOTO;ENCODING=BASE64;TYPE=JPEG:");
stringWrite.WriteLine(userPhotoString);
stringWrite.WriteLine(string.Empty);
}
//vCard End
stringWrite.WriteLine("END:VCARD");
savedCount++;
}
Console.WriteLine($"Total number of contacts with images saved: {savedCount}");
Console.WriteLine();
}
}
}
catch (Exception ex)
{
Console.WriteLine("Unknown error, if the error conitinues removing 'session.dat' file may help.\r\n" + ex.Message);
return;
}
}
