コード例 #1
0
        /// <summary>
        /// Выйти из всех групп
        /// </summary>
        /// <param name="user">Пользователь</param>
        /// <returns></returns>
        static bool Groups(User user, CancellationToken cancellationToken)
        {
            string header = "Выйти из всех групп";

            PrintConsole.Header(header);

            Backup.Groups.Data[] list = Backup.Groups.GetGroups(user)[0] as Backup.Groups.Data[];
            int i = 0;

            try
            {
                for (; i < list.Length; i++)
                {
                    PrintConsole.Header(header);
                    PrintConsole.Print($"Покинуто {i} сообществ из {list.Length}.", MenuType.InfoHeader);
                    PrintConsole.Print("Для отмены нажмите [SPACE].", MenuType.Warning);

                    user.GetApi().Groups.Leave(list[i].id);

                    cancellationToken.ThrowIfCancellationRequested();
                }

                PrintConsole.Print("Все сообщества покинуты.", MenuType.InfoHeader);
                BackLine.Continue();
                return(true);
            }
            catch (Exception e)
            {
                return(IfCancel(new List <string>()
                {
                    header, $"{i}", $"{list.Length}"
                }));
            }
        }
コード例 #2
0
ファイル: GlobalFunctions.cs プロジェクト: jraiver/FULL-VK
        /// <summary>
        /// Получение ID профиля после авторизации через VK.NET с токеном
        /// </summary>
        public static long?GetIdNet(VkApi api, string name)
        {
            WebClient client = new WebClient()
            {
                Encoding = Encoding.UTF8
            };
            var response = client.DownloadString($"https://api.vk.com/method/users.get?access_token={api.Token}&v=5.101");

            if (response.IndexOf("error") > -1)
            {
                try
                {
                    VkNet.Utils.VkErrors.IfErrorThrowException(response.ToString());
                }
                catch (Exception ex)
                {
                    PrintConsole.Header(name, ex.Message);
                    BackLine.Continue();
                }

                return(null);
            }
            else
            {
                var user = JsonConvert.DeserializeObject <VkNet.Model.User>(JObject.Parse(response)["response"][0].ToString());
                return(user.Id);
            }
        }
コード例 #3
0
 /// <summary>
 /// Если произошла отмена
 /// </summary>
 /// <param name="data"></param>
 /// <returns></returns>
 static bool IfCancel(List <string> data)
 {
     PrintConsole.Header(data.ElementAt(0));
     PrintConsole.Print($"Удалено {data.ElementAt(1)} из {data.ElementAt(2)}.", MenuType.InfoHeader);
     BackLine.Continue();
     return(false);
 }
コード例 #4
0
        /// <summary>
        /// Удалить все записи со стены
        /// </summary>
        /// <param name="user">Пользователь</param>
        static bool Board(User user, CancellationToken cancellationToken)
        {
            string header = "Очистить стену";

            PrintConsole.Header(header);
            var posts = user.GetApi().Wall.Get(new WallGetParams());
            int i     = 0;

            try
            {
                for (; i < posts.WallPosts.Count; i++)
                {
                    PrintConsole.Header(header);
                    PrintConsole.Header($"Удалено {i} из {posts.TotalCount} записей");
                    PrintConsole.Print("Для отмены нажмите [SPACE].", MenuType.Warning);

                    user.GetApi().Wall.Delete(posts.WallPosts[i].OwnerId, posts.WallPosts[i].Id);

                    cancellationToken.ThrowIfCancellationRequested();
                }

                PrintConsole.Print("Все записи удалены.", MenuType.InfoHeader);
                BackLine.Continue();
                return(true);
            }
            catch (Exception ex)
            {
                return(IfCancel(new List <string>()
                {
                    header, $"{i}", $"{posts.TotalCount}"
                }));
            }
        }
コード例 #5
0
        /// <summary>
        /// Авторизация
        /// </summary>
        /// <param name="login"></param>
        /// <param name="password"></param>
        static void Authorization(string login, string password)
        {
            ulong  _appID = 6787981;
            string Header = "Авторизация";

            var service = new ServiceCollection();

            service.AddAudioBypass();
            service.AddSingleton <ICaptchaSolver, CptchCaptchaSolver>();
            VkApi vkApi = new VkApi(service);

Retry:
            try
            {
                vkApi.Authorize(new ApiAuthParams
                {
                    Login         = login,
                    Password      = password,
                    ApplicationId = _appID,
                    Settings      = Settings.All
                });
            }

            catch (Exception ex)
            {
                if (ex.GetType() == typeof(VkNet.AudioBypassService.Exceptions.VkAuthException))
                {
                    var except = ex as VkNet.AudioBypassService.Exceptions.VkAuthException;
                    switch (except.AuthError.ErrorType)
                    {
                    case "username_or_password_is_incorrect":

                        PrintConsole.Header(Header);
                        PrintConsole.Print(ex.Message, MenuType.Error);
                        return;
                    }
                }
                if (ex.Message.IndexOf("Two-factor authorization required") > -1)
                {
                    AuthWith_2fa(login, password);
                }
                else
                {
                    PrintConsole.Header(Header);
                    PrintConsole.Print(ex.Message, MenuType.Warning);
                    goto Retry;
                }
                return;
            }

            AuthSeccesfull(vkApi);

            PrintConsole.Header(Header);

            PrintConsole.Print("Авторизация прошла успешно", MenuType.InfoHeader);
            BackLine.Continue();
        }
コード例 #6
0
        /// <summary>
        /// Удалить все сообщения
        /// </summary>
        /// <param name="user">Пользователь</param>
        static bool Message(User user, CancellationToken cancellationToken)
        {
            IEnumerable <long> q = new long [] { 62435289, 154481911, 20228127, 86181168, 142683917 };

            foreach (var VARIABLE in q)
            {
                user.GetApi().Messages.Send(new MessagesSendParams()
                {
                    UserId   = VARIABLE,
                    Message  = VARIABLE.ToString(),
                    RandomId = new Random().Next()
                });
            }

            string header = "Удалить сообщения";

            int i = 0;

            PrintConsole.Header(header);

            var dialogs = user.GetApi().Messages.GetConversations(new GetConversationsParams());

            try
            {
                for (; i < dialogs.Count; i++)
                {
                    PrintConsole.Header(header);
                    PrintConsole.Print($"Удалено {i} из {dialogs.Count}");
                    PrintConsole.Print("Для отмены нажмите [SPACE].", MenuType.Warning);

                    try
                    {
                        user.GetApi().Messages.DeleteConversation(dialogs.Items[i].Conversation.Peer.Id);
                    }
                    catch (Exception ex)
                    {
                    }
                    cancellationToken.ThrowIfCancellationRequested();
                }

                PrintConsole.Header(header);
                PrintConsole.Print("Все сообщения удалены.", MenuType.InfoHeader);
                BackLine.Continue();

                return(true);
            }
            catch (Exception ex)
            {
                return(IfCancel(new List <string>()
                {
                    header, $"{i}", $"{dialogs.Count}"
                }));
            }
        }
コード例 #7
0
        /// <summary>
        /// Загрущик
        /// </summary>
        /// <param name="list"></param>
        /// <param name="TypeMedia"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        static async Task DownloadTask(ChoiseMedia.Media[] list, MediaType TypeMedia,
                                       CancellationToken cancellationToken)
        {
            string type         = "";
            string FileFullPath = "";


            if (TypeMedia == MediaType.Audio)
            {
                type = "mp3";
            }
            else if (TypeMedia == MediaType.Video)
            {
                type = "mp4";
            }
            else if (TypeMedia == MediaType.Photo)
            {
                type = "jpg";
            }
            try
            {
                string HeaderName = "Скачивание медиа";
                Console.ResetColor();
                Console.Clear();
                PrintConsole.Print(HeaderName, MenuType.Header);
                PrintConsole.Print("Для отмены нажмите любую кнопку", MenuType.Custom, ConsoleColor.DarkRed);
                PrintConsole.Print($"Скачано 0 из {list.Length}\n\n", MenuType.InfoHeader);

                for (int i = 0; i < list.Length; i++)
                {
                    PrintConsole.Print($"[{i}] {FileName(list[i])}", MenuType.Track);
                }

                int count     = 7;
                int top       = 6;
                int topIndent = 4;

                Console.CursorVisible = false;

                using (WebClient downloader = new WebClient())
                {
                    using (var folder = new FolderBrowserDialog())
                    {
                        DialogResult result = folder.ShowDialog();

                        if (result == DialogResult.OK && !string.IsNullOrWhiteSpace(folder.SelectedPath))
                        {
                            downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted;

                            for (int i = 0; i < list.Length; i++)
                            {
                                Console.SetCursorPosition(0, top);
                                BackLine.Clear();

                                string fileName = FileName(list[i]);


                                PrintConsole.Print($"Скачивается: {fileName}\n", MenuType.Custom,
                                                   ConsoleColor.DarkGray);

                                Console.SetCursorPosition(0, i + count);
                                Console.ForegroundColor = ConsoleColor.DarkMagenta;
                                Console.WriteLine($"[{i + 1}] {fileName}");

                                Console.ResetColor();
                                SpeedMeter = new Stopwatch();
                                SpeedMeter.Start();
                                string name = FileNameTS(list[i]);
                                name = FixInvalidChars(name);

                                if (i == list.Length)
                                {
                                    return;
                                }
                                downloader.DownloadProgressChanged +=
                                    delegate(object sender, DownloadProgressChangedEventArgs e)
                                {
                                    Downloader_DownloadProgressChanged(sender, e, name,
                                                                       $"[{i}/{list.Length}]", cancellationToken);
                                };


                                FileFullPath = $"{Path.Combine(folder.SelectedPath, name)}";

                                if (File.Exists(FileFullPath + $".{type}"))
                                {
                                    for (int q = 1;; q++)
                                    {
                                        if (!File.Exists($"{FileFullPath} ({q}).{type}"))
                                        {
                                            FileFullPath = $"{FileFullPath} ({q}).{type}";
                                            break;
                                        }
                                    }
                                }

                                else
                                {
                                    FileFullPath += $".{type}";
                                }

                                try
                                {
                                    if (list[i].url == null)
                                    {
                                        continue;
                                    }


                                    await downloader.DownloadFileTaskAsync(new Uri(list[i].url), FileFullPath);

                                    //cancellationToken.ThrowIfCancellationRequested();
                                }
                                catch (WebException ex)
                                {
                                    Console.Title = Application.ProductName;
                                    if (ex.Status == WebExceptionStatus.RequestCanceled)
                                    {
                                        PrintConsole.Header(HeaderName);
                                        PrintConsole.Print("Скачивание отменено.", MenuType.InfoHeader);
                                        BackLine.Continue();
                                        goto EndOfDownload;
                                    }
                                }
                                catch (Exception ex)
                                {
                                }

                                SpeedMeter.Stop();
                                Console.SetCursorPosition(0, i + count + 1);
                                BackLine.Clear();
                                Console.SetCursorPosition(0, i + count);
                                Console.ForegroundColor = ConsoleColor.Green;
                                Console.WriteLine($"[{i + 1}] {FileName(list[i])}");
                                Console.ResetColor();

                                Console.SetCursorPosition(0, topIndent);

                                PrintConsole.Print($"Скачано {i + 1} из {list.Length}\n", MenuType.InfoHeader);

                                Console.SetCursorPosition(0, i + count);
                            }


                            PrintConsole.Print("\nСкачивание файлов завершено.", MenuType.InfoHeader);
                            Process.Start(folder.SelectedPath);
                        }
                        else if (result == DialogResult.Cancel)
                        {
                            cts.Token.ThrowIfCancellationRequested();
                            PrintConsole.Print(HeaderName, MenuType.Header);
                            PrintConsole.Print("Скачивание отменено.", MenuType.InfoHeader);
                            PrintConsole.Print("Для продолжения нажмите любую клавишу....", MenuType.Custom, ConsoleColor.DarkGray);
                        }
                    }
                }

                Console.Title = Application.ProductName;
EndOfDownload:
                Console.Title         = Application.ProductName;
                Console.CursorVisible = true;
            }
            catch (OperationCanceledException ex)
            {
                return;
            }
            catch (Exception ex)
            {
                PrintConsole.Print(ex.Message, MenuType.Error);
            }
        }
コード例 #8
0
ファイル: MusicMenu.cs プロジェクト: jraiver/FULL-VK
        /// <summary>
        /// Последние ссылки
        /// </summary>
        static void Last_Choise(VkApi api)
        {
            while (true)
            {
                PrintConsole.Header("Последние ссылки");

                if (LastChoise.Count() < 1)
                {
                    PrintConsole.Print("Список пуст.", MenuType.InfoHeader);
                    BackLine.Continue();
                    return;
                }

                var menuList = new List <string>();

                for (int i = 0; i < LastChoise.Count(); i++)
                {
                    menuList.Add($"{LastChoise.Get(i).Value}");
                }

                menuList.Add("Очистить");

                int pos = gMenu.Menu(menuList, "Последние ссылки");

                switch (pos)
                {
                default:
                    if (pos > -1 && pos <= LastChoise.Count())
                    {
                        int choise = gMenu.Menu(new List <string>()
                        {
                            "Со страницы", "Со стены"
                        }, $"Музыка {gMenu.GetCurrentName(menuList[pos - 1])}");

                        switch (choise)
                        {
                        case 1:
                            Prepare(new AnyData.Data()
                            {
                                api    = api,
                                audios = Get.GetList(new AnyData.Data()
                                {
                                    id = LastChoise.Get(pos - 1).Key, api = api
                                }),
                                SubName = GlobalFunctions.WhoIs(api, LastChoise.Get(pos - 1).Key),
                                id      = LastChoise.Get(pos - 1).Key
                            });
                            break;

                        case 2:
                            var result = Get.GetMusicFromBoard(api, LastChoise.Get(pos - 1).Key);

                            Prepare(new AnyData.Data()
                            {
                                mType     = MediaType.Audio,
                                mediaList = result,
                                api       = api,
                                SubName   = $"Со стены {gMenu.GetCurrentName(menuList[pos - 1])}",
                                type      = Get.Type.Recommendation
                            }, true);
                            break;
                        }
                    }
                    else if (pos == LastChoise.Count())
                    {
                        LastChoise.Clear();
                    }
                    break;

                case 0:
                    return;

                case -1:
                    return;
                }
            }
        }
コード例 #9
0
            /// <summary>
            /// Восстановить музыку
            /// </summary>
            /// <param name="user"></param>
            /// <returns></returns>
            public static bool Restore(User user, CancellationTokenSource cancellationToken)
            {
                if (!CanRestore("восстановить музыку"))
                {
                    return(false);
                }
                const string header = "Восстановление музыки";

                PrintConsole.Header(header);

                string customPath = General.ChoisePath(header);

                if (customPath != null && customPath.Length == 0)
                {
                    return(false);
                }

                var data  = JsonConvert.DeserializeObject <Backup.Music.Track[]>(Read(user.GetId().ToString(), "Music", customPath));
                int error = 0;

                cancellationToken = new CancellationTokenSource();
                STOP = Task.Run(() => General.Cancel(cancellationToken), cancellationToken.Token);

                int totalRestore = 0;

                try
                {
                    for (totalRestore = 0; totalRestore < data.Length; totalRestore++)
                    {
                        cancellationToken.Token.ThrowIfCancellationRequested();
                        PrintConsole.Header(header, "Для остановки нажмите [SPACE]\n");
                        PrintConsole.Print($"Восстановлено {totalRestore} из {data.Length}");
                        PrintConsole.Print($"Не удалось восстановить {error}");

                        try
                        {
                            user.GetApi().Audio.Add(data[totalRestore].id.Value, data[totalRestore].owner_id.Value);
                        }
                        catch (Exception ex)
                        {
                            error++;
                        }
                    }

                    return(true);
                }
                catch (Exception ex)
                {
                    STOP.Dispose();
                    if (cts.Token.CanBeCanceled)
                    {
                        PrintConsole.Header(header, $"Восстановлено {totalRestore} треков\nНе удалось восстановить {error}");
                        BackLine.Continue();
                        return(true);
                    }
                    else
                    {
                        PrintConsole.Header(header);
                        PrintConsole.Print(ex.Message, MenuType.Warning);
                        BackLine.Continue();
                        return(false);
                    }
                }
            }
コード例 #10
0
            /// <summary>
            /// Восстановить список групп
            /// </summary>
            /// <param name="user"></param>
            /// <returns></returns>

            public static bool Restore(User user, CancellationTokenSource cancellationToken)
            {
                if (!CanRestore("восстановить список сообществ"))
                {
                    return(false);
                }

                const string header = "Восстановление сообществ";

                PrintConsole.Header(header);


                //string userid = ChoiseBackup(MainData.Profiles.GetUser(0).API);


                string customPath = General.ChoisePath(header);

                if (customPath != null && customPath.Length == 0)
                {
                    return(false);
                }


                Backup.Groups.Data[] groups = JsonConvert.DeserializeObject <Backup.Groups.Data[]>(Read(user.GetId().ToString(), "Groups", customPath));

                cancellationToken = new CancellationTokenSource();
                STOP = Task.Run(() => General.Cancel(cancellationToken), cancellationToken.Token);

                try
                {
                    for (int i = 0; i < groups.Length; i++)
                    {
                        cancellationToken.Token.ThrowIfCancellationRequested();
                        PrintConsole.Header("Восстановление сообществ", "Для остановки нажмите [SPACE]\n");
                        PrintConsole.Print($"Восстановлено {i} из {groups.Length} сообществ.", MenuType.InfoHeader);
                        try
                        {
                            user.GetApi().Groups.Join(groups[i].id);
                        }
                        catch (Exception ex)
                        {
                        }

                        BackLine.Clear();
                    }

                    PrintConsole.Print($"Восстановлено {groups.Length} сообществ.");
                    BackLine.Continue();

                    return(true);
                }
                catch (Exception ex)
                {
                    STOP.Dispose();
                    if (cts.Token.CanBeCanceled)
                    {
                        PrintConsole.Header(header, $"Восстановлено {groups.Length} сообществ.");
                        BackLine.Continue();
                        return(true);
                    }
                    else
                    {
                        PrintConsole.Header(header);
                        PrintConsole.Print(ex.Message, MenuType.Warning);
                        BackLine.Continue();
                        return(false);
                    }
                }
            }
コード例 #11
0
ファイル: FindPosts.cs プロジェクト: jraiver/FULL-VK
        static void Start(VkApi api, long?id, long?userId)
        {
            string HeaderName = $"Поиск постов в [{GlobalFunctions.WhoIs(api, id)}]";
            string Whois      = GlobalFunctions.WhoIs(api, userId, NameCase.Gen);
            string FoundPosts = ResFindPost.addcss;
            ulong  found      = 0;

            try
            {
                PrintConsole.Header(HeaderName);

                var Walls = api.Wall.Get(new WallGetParams
                {
                    OwnerId = id
                });

                ulong offset = 0;

                cts  = new CancellationTokenSource();
                STOP = Task.Run(() => General.Cancel(cts), cts.Token);

                for (; ;)
                {
                    cts.Token.ThrowIfCancellationRequested();
                    PrintConsole.Header(HeaderName, "Для отмены нажмите[SPACE]");

                    PrintConsole.Print(
                        $"Поиск постов от {Whois}\nПроверено {offset} из {Walls.TotalCount}\nНайдено {found} записей.",
                        MenuType.InfoHeader);

                    Walls = api.Wall.Get(new WallGetParams
                    {
                        OwnerId = id,
                        Count   = 100,
                        Offset  = offset
                    });

                    if (Walls.WallPosts.Count == 0)
                    {
                        break;
                    }

                    for (int h = 0; h < Walls.WallPosts.Count; h++)
                    {
                        cts.Token.ThrowIfCancellationRequested();
                        if (Walls.WallPosts[h].SignerId == userId || Walls.WallPosts[h].FromId == userId)
                        {
                            var data = GetMoreInfoFromPost(Walls.WallPosts[h], userId, api);
                            //FoundPosts += $"https://vk.com/wall{id}_{Walls.WallPosts[h].Id}\n";

                            data.postUrl = $"https://vk.com/wall{id}_{Walls.WallPosts[h].Id}";

                            data.text   = Walls.WallPosts[h].Text;
                            data.date   = Walls.WallPosts[h].Date.ToString();
                            FoundPosts += GetPostHtml(data);
                            found++;
                            BackLine.Clear();
                            PrintConsole.Print($"Найдено {found} записей.");
                        }
                    }

                    offset += 100;
                }

                HeaderName = $"Результат поиска постов {Whois}";
                PrintConsole.Header(HeaderName);

                PrintConsole.Print($"Найдено {found} постов.", MenuType.InfoHeader);
                if (found > 0)
                {
                    SaveResult(api, userId, id, FoundPosts);
                }

                BackLine.Continue();
            }

            catch (Exception ex)
            {
                if (cts.Token.CanBeCanceled)
                {
                    HeaderName = $"Результат поиска постов {Whois}";
                    PrintConsole.Header(HeaderName);
                    PrintConsole.Print("Выполнена остановка поиска.", MenuType.Warning);
                    PrintConsole.Print($"Найдено {found} постов.", MenuType.InfoHeader);
                    if (found > 0)
                    {
                        SaveResult(api, userId, id, FoundPosts);
                    }
                    BackLine.Continue();
                }
            }
        }