public static async void Login(string token)
{
await Api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = token
});
CurrentUser = GetCurrentUser();
}
//Логин по токену
public static async Task <VkApi> Login(string token)
{
await Api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = token
});
return(Api);
}
public override async Task <UpdateHandlingResult> HandleCommand(IBot bot, Update update,
DialogsCommandArgs args)
{
var botUser = _botUserRepository.GetByTelegramId(update.Message.Chat.Id);
if (botUser.VkAccount == null)
{
await bot.Client.SendTextMessageAsync(update.Message.Chat.Id, "`Необходима авторизация`", ParseMode.Markdown);
return(UpdateHandlingResult.Handled);
}
var api = new VkApi();
await api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = botUser.VkAccount.AcessToken
});
var start = HandleArgs(args);
var dialogsMarkup = Markup.Dialogs(api, start, DefaultCount);
await bot.Client.SendTextMessageAsync(
update.Message.Chat.Id,
"Выберете диалог:",
replyMarkup : dialogsMarkup);
return(UpdateHandlingResult.Handled);
}
public async Task <UpdateHandlingResult> HandleUpdateAsync(IBot bot, Update update)
{
var message = update.Message;
var botUser = _botUserRepository.GetByTelegramId(message.Chat.Id);
if (botUser.VkAccount == null)
{
throw new ArgumentNullException();
}
var vkApi = new VkApi();
await vkApi.AuthorizeAsync(new ApiAuthParams
{
AccessToken = botUser.VkAccount.AcessToken
});
try
{
var messagesSendParams = await GetMessagesSendParams(bot, botUser, message, vkApi);
var sendedMsgId = await vkApi.Messages.SendAsync(messagesSendParams);
}
catch (Exception e)
{
Console.WriteLine(e);
await bot.Client.SendTextMessageAsync(
update.Message.Chat.Id,
$"Ошибка доставки сообщения::{e.Message}",
replyToMessageId : message.MessageId);
}
return(UpdateHandlingResult.Handled);
}
public async Task <UpdateHandlingResult> HandleUpdateAsync(IBot bot, Update update)
{
var botUser = _botUserRepository.GetByTelegramId(update.CallbackQuery.Message.Chat.Id);
if (botUser.VkAccount == null)
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Необходима авторизация");
}
var api = new VkApi();
await api.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = botUser.VkAccount.AcessToken
});
if (!long.TryParse(update.CallbackQuery.Data.Substring(Constants.MessageForward.Length),
out var forwardedMsgId))
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Сообщение не найдено");
}
await api.Messages.SendAsync(new MessagesSendParams()
{
PeerId = botUser.VkAccount.CurrentPeer,
Message = "fwd",
ForwardMessages = new long[] { forwardedMsgId }
});
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Сообщение переслано в текущий диалог");
return(UpdateHandlingResult.Handled);
}
public static async Task Transfer(this TransmittedMessage transmittedMessage)
{
var bodyText = transmittedMessage.Body.Text;
if (bodyText == null)
{
throw new ArgumentException($"Сообщение пустое");
}
var api = new VkApi();
await api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = transmittedMessage.AuthorizedSender.AccessToken
});
var receiverIds = transmittedMessage.Receivers
.Select(receiver => api.GetReceiverId(receiver.Id));
foreach (var receiverId in receiverIds)
{
await api.Messages.SendAsync(new MessagesSendParams
{
Message = bodyText,
PeerId = receiverId
});
}
}
private async Task AuthAsync(ApiAuthParams authParams)
{
try
{
Api = new VkApi()
{
CaptchaSolver = new CaptchaSolver(userInputService)
};
Api.SetLanguage(VkNet.Enums.Language.Ru);
await Api.AuthorizeAsync(authParams);
var user = await GetCurrentUserAsync();
Group group = null;
if (!string.IsNullOrEmpty(groupIdOrScreenName))
{
group = await GetCurrentGroupAsync(groupIdOrScreenName);
GroupId = group.Id;
GroupScreenName = group?.ScreenName;
}
RiseAuthStateChanged(CreateUserAuthorizeEventArgs(true, Token, user, group));
}
catch (UserAuthorizationFailException)
{
RiseAuthStateChanged(CreateUserAuthorizeEventArgs(false, ""));
}
catch (NullReferenceException)
{
throw new Exception("Ошибка авторизации. Авторизуйтесь через браузер");
}
}
public async Task <UpdateHandlingResult> HandleUpdateAsync(IBot bot, Update update)
{
var botUser = _botUserRepository.GetByTelegramId(update.CallbackQuery.Message.Chat.Id);
if (botUser.VkAccount == null)
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Необходима авторизация");
}
var vkApi = new VkApi();
await vkApi.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = botUser.VkAccount.AcessToken
});
if (!ulong.TryParse(update.CallbackQuery.Data.Substring(Constants.MessageForward.Length),
out var msgToDeleteId))
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Сообщение не найдено");
}
try
{
vkApi.Messages.Delete(new ulong[] { msgToDeleteId }, false, true);
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Сообщение удалено");
}
catch (Exception e)
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Не получилось удалить сообщение");
Console.WriteLine(e);
}
return(UpdateHandlingResult.Handled);
}
public static async Task <VkApi> Get()
{
commandsList = new List <Command>
{
//Основные
new StartCommand(),
new StartLowerCommand(),
new StartPLCommand(),
new SelectRoleCommand(),
new SelectBackCommand(),
//Education
new SelectEducationCommand(),
new SelectBuyEnergyCommand(),
//World
//Home
new SelectHomeCommand(),
new SelectMyEquipCommand(),
new SelectDoEatCommand(),
new SelectDoSleepCommand(),
new SelectHelpMeCommand(),
new SelectMyStatsCommand(),
//CityGate
new SelectCityGateCommand(),
new SelectWalkingCommand(),
new SelectSendMoneyCommand(),
//Маркетплейс
new SelectMarketDistrictCommand(),
//Городская площадь
new SelectTownSquareCommand(),
new SelectDocServiceCommand(),
new SelectGetPassportCommand(),
new SelectBankCommand(),
new SelectGetBankCardCommand(),
//PvP Арена
new SelectPvPArenaCommand(),
new SelectFightModeCommand(),
new SelectFightingCommand(),
//подземелье
new SelectDungeonCommand(),
new SelectLevelCommand(),
new SelectBossFightCommand(),
};
client = new VkApi();
await client.AuthorizeAsync(new ApiAuthParams
{
AccessToken = AppSettings.Token
});
return(client);
}
public async Task <VkUserModel> Auth(string login, string password)
{
try
{
await user.AuthorizeAsync(new ApiAuthParams
{
ApplicationId = Properties.Socials.Default.VkAppId,
Login = login,
Password = password,
Settings = Settings.All,
TwoFactorAuthorization = (this.AuthUsing2FA) ? Auth2Fa : default(Func <string>)
});
if (user.IsAuthorized)
{
var info = await user.Account.GetProfileInfoAsync();
var photo = user.Photo.Get(new PhotoGetParams
{
AlbumId = PhotoAlbumType.Profile,
Reversed = true,
Count = 1,
});
var bitmapPhoto = new BitmapImage();
bitmapPhoto.BeginInit();
bitmapPhoto.UriSource = photo[0].Sizes[0].Url;
bitmapPhoto.EndInit();
var vkuser = (new VkUserModel
{
userId = (int)user.UserId,
photo = bitmapPhoto,
userToken = user.Token,
userName = info.FirstName,
userSurname = info.LastName,
screenName = info.ScreenName,
FullName = $"{info.FirstName} {info.LastName}"
});
user.OnTokenExpires += user => user.RefreshToken();
Properties.Socials.Default.VkUserId = (ulong)user.UserId;
Properties.Settings.Default.Save();
SendAnswerMessage("Смотрю вы подключили Ducky к VK! Буду рад помогать, кря!", vkuser.userId);
return(vkuser);
}
else
{
return(null);
}
}
catch (Exception e)
{
MethodBase m = MethodBase.GetCurrentMethod();
log.AddLog("ERROR : ", e.Message, "Error in ", m.DeclaringType.Name);
return(null);
}
}
public async Task <IVkApi> GetAuthorizedApiAsync(string accessToken)
{
var api = new VkApi();
await api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = accessToken
});
return(api);
}
private static async Task <VkApi> CreateClientAsync(ulong applicationId, string accessToken, ILogger <VkApi> log)
{
var vkApi = new VkApi(log);
await vkApi.AuthorizeAsync(new ApiAuthParams
{
ApplicationId = applicationId,
AccessToken = accessToken
});
return(vkApi);
}
private async Task <Video> UploadVideoToVk(VkApi api, Channel channel, PlaylistItemSnippet item)
{
await api.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = channel.VkToken,
ApplicationId = _settings.ApplicationId,
UserId = long.Parse(channel.VkUserId)
});
if (!api.IsAuthorized)
{
throw new Exception(
$"Vk api client not authorized. YtName = {channel.YtName}, Video Id = {item.ResourceId.VideoId}");
}
var sVideo = api.Video.Save(new VideoSaveParams()
{
Name = item.Title,
Link = $"https://www.youtube.com/watch?v={item.ResourceId.VideoId}",
Wallpost = false,
GroupId = int.Parse(channel.VkGroupId)
});
using (HttpClient client = new HttpClient())
using (var message = new HttpRequestMessage(HttpMethod.Get, sVideo.UploadUrl))
{
var response = await client.SendAsync(message);
if (!response.IsSuccessStatusCode)
{
throw new Exception(
$"Error loading video {response.StatusCode}: {response.ReasonPhrase}: Yt id={item.ResourceId.VideoId} Vk id={sVideo.Id}");
}
Logger.Info($"Video uploaded to vk. Yt id={item.ResourceId.VideoId} Vk id={sVideo.Id} Status: {response.StatusCode} Reason: {response.ReasonPhrase}");
}
Thread.Sleep(300);
var uploadedVideo = api.Video.Get(new VideoGetParams
{
Videos = new[]
{
new Video()
{
OwnerId = -long.Parse(channel.VkGroupId),
Id = sVideo.Id
}
},
OwnerId = -long.Parse(channel.VkGroupId),
Extended = true
}).FirstOrDefault();
return(uploadedVideo);
}
public async Task AuthorizeAsync()
{
try
{
await _vkApi.AuthorizeAsync((ApiAuthParams)JsonConvert.DeserializeObject(File.ReadAllText(_pathToAuthParams), typeof(ApiAuthParams)));
}
catch (Exception ex)
{
RaiseLog(Discord.LogSeverity.Error, "Error of authorization", ex);
return;
}
RaiseLog(Discord.LogSeverity.Info, "Authorized");
}
// public static async Task<VkClient> GetUncheckedClient(VkAcc vkAcc)
// {
// VkClient vkClient = vkAcc.VkClients.Find(e => e.ClientStatus == VkClient.Status.Unchecked);
// if (vkClient == null)
// {
// await UpdateClientsFromVkBySearchconfig(vkAcc);
// vkClient = vkAcc.VkClients.Find(e => e.ClientStatus == VkClient.Status.Unchecked);
// }
// return vkClient;
// }
// public static async Task<int> UpdateClientsFromVkBySearchconfig(VkAcc vkAcc, uint WantedCount = 200)
// {
// uint UpdatedCount = 0;
// uint Offset = 0;
// var vkApi = _getApi(vkAcc);
// if (_isVkApiActive(vkApi))
// {
// using (var context = new AutoVkContext())
// {
// while (UpdatedCount < WantedCount)
// {
// var clientsSearch = vkApi.Users.Search(new UserSearchParams()
// {
// City = vkAcc.City,
// Country = vkAcc.Country,
// AgeFrom = (ushort)vkAcc.AgeFrom,
// AgeTo = (ushort)vkAcc.AgeTo,
// Sex = (VkNet.Enums.Sex)vkAcc.Sex,
// BirthMonth = (ushort)vkAcc.BirthMonth,
// BirthDay = (ushort)vkAcc.BirthDay,
// Online = true,
// HasPhoto = true,
// Count = WantedCount,
// Offset = Offset,
// });
// foreach (var clientSearch in clientsSearch)
// {
// if (!vkAcc.VkClients.Exists(e => e.ProfileVkId == clientSearch.Id) && clientSearch.IsClosed != true)
// {
// var vkClient = new VkClient()
// {
// ClientStatus = VkClient.Status.Unchecked,
// VkAccId = vkAcc.VkAccId,
// ProfileVkId = (int)clientSearch.Id
// };
// vkAcc.VkClients.Add(vkClient);
// context.VkClients.Add(vkClient);
// UpdatedCount++;
// }
// }
// Offset += WantedCount;
// if (clientsSearch.TotalCount < Offset)
// {
// context.SaveChanges();
// return (int)UpdatedCount;
// }
// }
// context.SaveChanges();
// }
// return (int)UpdatedCount;
// }
// return -1;
// }
public static async Task <Boolean> TryAuthorize(string accessToken)
{
var vkApi = new VkApi();
await vkApi.AuthorizeAsync(new ApiAuthParams
{
AccessToken = accessToken
});
if (_isVkApiActive(vkApi))
{
return(true);
}
return(false);
}
public async Task AuthorizeAsync()
{
if (api.IsAuthorized)
{
return;
}
await api.AuthorizeAsync(new ApiAuthParams()
{
ApplicationId = _options.ApplicationId,
Login = _options.Login,
Password = _options.Password,
Settings = Settings.Wall
});
}
public async Task SignInAsync(String login, String password, long?captchaSid = null, string captchaValue = null)
{
await VKAPI.AuthorizeAsync(new ApiAuthParams()
{
ApplicationId = VKAPIApplicationID,
Login = login,
Password = password,
Settings = Settings.All,
CaptchaSid = captchaSid,
CaptchaKey = captchaValue
});
RegisterTask();
SaveCredentials(login, password);
}
public async Task Initialize()
{
_api = new VkApi();
var vkSecret =
await _vkSecretProvider.GetSecret();
await _api.AuthorizeAsync(new ApiAuthParams()
{
ClientSecret = vkSecret.ClientSecret,
AccessToken = vkSecret.AccessToken,
ApplicationId = vkSecret.ApplicationId,
Settings = Settings.All
});
}
/// <summary>
/// Auth in VK async
/// </summary>
/// <param name="login">VK login</param>
/// <param name="password">VK password</param>
/// <returns></returns>
public static async Task AuthAsync(string login, string password)
{
var services = new ServiceCollection();
services.AddAudioBypass();
var api = new VkApi(services);
await api.AuthorizeAsync(new VkNet.Model.ApiAuthParams
{
Login = login,
Password = password
});
Program._vkApi = api;
Console.WriteLine(new LogMessage(LogSeverity.Verbose, "VK.net", "Joined"));
}
public async Task <bool> Token(string token)
{
try
{
await Api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = token,
Settings = Settings.All
});
if (Api.IsAuthorized)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Авторизация по acess_token с проверкой его валидности
/// </summary>
/// <remarks>
/// Т.к. поле vkApi.IsAuthorized при авторизации с невалидным acess_token
/// остается истиным, а метод api.Authorize не кидает исключение, то пришлось
/// написать такую проверку авторизации
/// </remarks>
public static async Task CheckedAuthorizeAsync(this VkApi api, string accessToken)
{
await api.AuthorizeAsync(new ApiAuthParams
{
AccessToken = accessToken
});
try
{
await api.Account.SetOfflineAsync();
}
catch (UserAuthorizationFailException e)
{
throw new UserAuthorizationFailException($"Ошибка авторизации. Не действительный access_token: {accessToken}");
}
}
static void Main(string[] args)
{
System.Console.OutputEncoding = Encoding.UTF8;
System.Console.InputEncoding = Encoding.UTF8;
var api = new VkApi();
api.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = ""
});
var ch = new Core.Onliner(api);
var res = ch.Check().Result;
}
private static async Task AuthVK()
{
await s_VKAPI.AuthorizeAsync(new ApiAuthParams
{
Settings = Settings.Audio,
Password = s_VKPassword,
Login = s_VKLogin,
TwoFactorSupported = true,
TokenExpireTime = 0,
ForceSms = false,
TwoFactorAuthorization = () =>
{
Log.Information("Enter 2FA code");
return(Console.ReadLine());
}
});
}
private async void Enter_Click(object sender, RoutedEventArgs e)
{
VkApi api = App.Api;
await api.AuthorizeAsync(new ApiAuthParams()
{
Settings = Settings.All,
Login = EmailOrPhone.Text,
Password = Password.Password,
ApplicationId = App.AppId
});
App.Token = App.Api.Token;
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
File.Create(localFolder.Path + "Token.txt");
File.WriteAllText(localFolder.Path + "Token.txt", App.Token);
}
public async Task <UpdateHandlingResult> HandleUpdateAsync(IBot bot, Update update)
{
var botUser = _botUserRepository.GetByTelegramId(update.CallbackQuery.Message.Chat.Id);
if (botUser.VkAccount == null)
{
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Необходима авторизация");
}
var vkApi = new VkApi();
await vkApi.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = botUser.VkAccount.AcessToken
});
// like / type / id / owner
var args = update.CallbackQuery.Data.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
var type = args[1];
var id = long.Parse(args[2]);
var owner = long.Parse(args[3]);
var isLiked = await vkApi.Likes.IsLikedAsync(LikeObjectType.Post, id, ownerId : owner);
if (isLiked)
{
await vkApi.Likes.DeleteAsync(LikeObjectType.Post, id, owner);
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Лайк убран");
}
else
{
await vkApi.Likes.AddAsync(new LikesAddParams()
{
// Тут надо выбирать тип в зависимости от аргументов. А то тупо получается
Type = LikeObjectType.Post,
ItemId = id,
OwnerId = owner
});
await bot.Client.AnswerCallbackQueryAsync(update.CallbackQuery.Id, "Лайк добавлен");
}
return(UpdateHandlingResult.Handled);
}
public async static Task Auto(string token, ICaptchaSolver captchaSolver)
{
var services = new ServiceCollection();
services.AddAudioBypass();
var api = new VkApi(services);
api.CaptchaSolver = captchaSolver;
await api.AuthorizeAsync(new ApiAuthParams()
{
AccessToken = token
});
StaticContent.VkApi = api;
var userInfo = await Users.Info.CurrentUser();
StaticContent.UserId = userInfo.Id;
}
private static async Task <string> GetAccessTokenAsync(AuthData authData)
{
try
{
var api = new VkApi();
await api.AuthorizeAsync(new ApiAuthParams
{
Login = authData.Username,
Password = NullIfEmpty(authData.Password),
ApplicationId = authData.ApplicationId,
Settings = Settings.All,
TwoFactorAuthorization = PromptForSecondAuthFactor,
AccessToken = NullIfEmpty(authData.AccessToken)
});
return(api.Token);
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
public async Task EnableNotifications(BotUser botUser)
{
var userTelegramId = botUser.TelegramUserId;
if (_listeningTaskIsActive.ContainsKey(userTelegramId) && _listeningTaskIsActive[userTelegramId])
{
throw new ArgumentException(
$"Получение уведомлений для пользователя tgid{userTelegramId} уже включено");
}
if (botUser.VkAccount == null)
{
throw new ArgumentNullException(nameof(botUser.VkAccount), "Необходима авторизация Вконтакте");
}
var vkApi = new VkApi();
await vkApi.AuthorizeAsync(new ApiAuthParams
{
AccessToken = botUser.VkAccount.AcessToken
});
var longPollListener = new LongPollListener(vkApi,
newMessage: async(owner, newMessage) =>
{
var msgArr = await vkApi.Messages.GetByIdAsync(new[] { newMessage.MsgId });
var msg = msgArr.FirstOrDefault();
if (msg == null)
{
return;
}
await DeliverMessageToUser(botUser, vkApi, msg);
}
);
longPollListener.Start();
}
public async static Task <string> User(string login, string password, Func <string> twoFactorAuth, ICaptchaSolver captchaSolver)
{
var services = new ServiceCollection();
services.AddAudioBypass();
var api = new VkApi(services);
api.CaptchaSolver = captchaSolver;
await api.AuthorizeAsync(new ApiAuthParams()
{
Login = login,
Password = password,
TwoFactorAuthorization = twoFactorAuth
});
StaticContent.VkApi = api;
var userInfo = await Users.Info.CurrentUser();
StaticContent.UserId = userInfo.Id;
return(api.Token);
}
/// <summary>
/// Метод авторизации Вконтакте
/// </summary>
/// <inheritdoc/>
public async Task <string> VkAuthAsync(string log, string pass)
{
login = log;
password = pass;
var services = new ServiceCollection();
services.AddAudioBypass();
api = new VkApi(services);
await api.AuthorizeAsync(new ApiAuthParams
{
ApplicationId = 7062393,
Login = login,
Password = password,
Settings = Settings.All,
TwoFactorAuthorization = () =>
{
throw new Exception("двухфакторка");
}
});
return(api.Token);
}
