<Window x:Class="SearchJobParser.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:SearchJobParser"
        mc:Ignorable="d"
        Title="Парсер сайта поиска работ" Icon="Resources/search.ico" MaxHeight="350" MinHeight="350" MaxWidth="500" MinWidth="500">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="0.05*"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="0.05*"/>
        </Grid.RowDefinitions>
        <Frame x:Name="mainFrame" Grid.Row="1"/>
        <Grid Grid.Row="0" Style="{StaticResource rowBorder}"/>
        <Grid Grid.Row="2" Style="{StaticResource rowBorder}"/>
        
    </Grid>
</Window>

using SearchJobParser.Class.Service;
using SearchJobParser.Pages;
using System.Windows;

namespace SearchJobParser
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            mainFrame.Navigate(new mainPage());
            mainFrame.NavigationUIVisibility = System.Windows.Navigation.NavigationUIVisibility.Hidden;
            Manager.mainFrame = mainFrame;
        }
    }
}

namespace SearchJobParser.Class.Model
{
    internal class Area
    {
        public string Name;
        public Area[] Areas;
        public Area(string name, Area[] areas)
        {
            Name = name;
            Areas = areas;
        }
    }
}

namespace SearchJobParser.Class.Model
{
    internal class Country
    {
        public string Name;
        public Area[] Area;
        public Country(string name, Area[] areas)
        {
            Name = name;
            Area = areas;
        }
    }
}

namespace SearchJobParser.Class.Model
{
    public enum CountryType
    {
        Russia = 0,
        Ukraine = 1,
        kazakhstan = 2,
        Belarus = 5
    }
}

namespace SearchJobParser.Class.Model
{
    internal enum JobSiteName
    {
        HHRU = 0,
        SuperJob = 1
    }
}

namespace SearchJobParser.Class.Model
{
    enum MessageType
    {
        INFO = 0,
        WARN = 1,
        ERR = 2
    }
}

namespace SearchJobParser.Class.Model
{
    internal class ParseData
    {
        public string JobTitle { get; private set; }
        public string Salary { get;private set; }
        public string Experience { get; private set; }
        public string Format { get; private set; }
        public string  Worktime { get; private set; }
        public string Link { get;private set; }
        public JobSiteName SiteName { get; private set; }
        public string Description { get; private set; }

        public ParseData(string jobTitle, string salary, string experience, string format, string link, JobSiteName siteName = JobSiteName.HHRU, string worktime = null, string description = null)
        {
            JobTitle = jobTitle;
            Salary = salary;
            Experience = experience;
            Format = format;
            Worktime = worktime;
            Link = link;
            SiteName = siteName;
            Description = description;
        }
    }
}

using Newtonsoft.Json;
using SearchJobParser.Class.Model;
using System.Collections.Generic;
using System.IO;
using System.Net;

namespace SearchJobParser.Class.Service
{
    internal class ResourceCities
    {
        private Logger logger = new Logger();
        private static Area[] areas;
        public ResourceCities() => areas = ParsedCities();
        public string[] GetCities()
        {
            List<string> cities = areas?.Length > 0 ? new List<string>(areas.Length) : null;
            if (areas != null)
            {
                foreach (Area city in areas)
                    cities.Add(city.Name);
            } else
                areas = ParsedCities();
            return cities?.Count > 0 ? cities.ToArray() : null;
        }
        public string[] GetChildCities(in string parentCities)
        {
            List<string> childCities = null; 
            foreach (Area area in areas)
            {
                if (area.Name == parentCities)
                {
                    childCities = area?.Areas.Length > 0 ? new List<string>(areas.Length) : null;
                    foreach (Area child in area.Areas)
                        childCities.Add(child.Name);
                }
                else
                    continue;
            }
            return childCities?.Count > 0? childCities.ToArray() : null;
        }
        private Area[] ParsedCities()
        {
            string url = "https://api.hh.ru/areas";
            string result = "";
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                using (StreamReader reader = new StreamReader(response.GetResponseStream()))
                    result = reader.ReadToEnd();
                Country[] countries = JsonConvert.DeserializeObject<Country[]>(result);
                return countries[(int)CountryType.Russia].Area;
            }
            catch (WebException ex)
            {
                logger.WriteLog(ex.Message, MessageType.ERR);
            }
            return null;
        }
    }
}

using System.Windows.Controls;

namespace SearchJobParser.Class.Service
{
    internal class Manager
    {
        public static Frame mainFrame { get; set; }
    }
}

using SearchJobParser.Class.Model;
using System;
using System.IO;
using System.Threading;

namespace SearchJobParser.Class.Service
{
    internal class Logger
    {
        private string fileName = "log.log";
        private const int mbSize = 1000000;
        private static readonly SemaphoreSlim lockFile = new SemaphoreSlim(1, 1);

        public void WriteLog(string message, MessageType type = MessageType.INFO)
        {
            CheckSize();
            lockFile.Wait();
            using (StreamWriter writer = new StreamWriter(fileName, true))
                 writer.WriteLineAsync($"|{type}| {DateTime.Now} {message}");
            lockFile.Release();
            
        }
        private void CheckSize()
        {
            FileInfo file = new FileInfo(fileName);
            if (file.Exists)
            {
                if (file.Length > mbSize)
                {
                    file.CopyTo($"log_{DateTime.Today.ToString("MM-dd-yyyy")}.log", false);
                    file.Delete();
                }
            } else
                file.Create().Close();
        }
    }
}

using OfficeOpenXml;
using SearchJobParser.Class.Model;
using System;
using System.Collections.Generic;
using System.IO;

namespace SearchJobParser.Class.Service
{
    internal class ExcelMaker
    {
        public void SaveData(ref List<ParseData> data)
        {
            ExcelPackage.License.SetNonCommercialOrganization("My Noncommercial organization");
            string path = $@"report_{DateTime.Now.ToShortDateString()}.xlsx";
            FileInfo excelFile = new FileInfo(path);
            using (ExcelPackage excel = new ExcelPackage(excelFile))
            {
                excel.Workbook.Worksheets.Add("отчет");
                ExcelWorksheet worksheetClient = excel.Workbook.Worksheets["отчет"];
                string[] header = new string[] { "Должность", "Сайт", "Зарплата", "Опыт", "Формат", "Ссылка" };
                for (int i = 1; i < header.Length + 1; i++)
                    worksheetClient.Cells[1, i].Value = header[i - 1];
                for (int i = 0; i < data.Count; i++)
                {
                    worksheetClient.Cells[i + 2, 1].Value = data[i].JobTitle;
                    worksheetClient.Cells[i + 2, 2].Value = data[i].SiteName == JobSiteName.HHRU ? "HH.RU" : "SuperJob";
                    worksheetClient.Cells[i + 2, 3].Value = data[i].Salary;
                    worksheetClient.Cells[i + 2, 4].Value = data[i].Experience;
                    worksheetClient.Cells[i + 2, 5].Value = data[i].Format?.Trim() == null? "Пусто" : data[i]?.Format;
                    worksheetClient.Cells[i + 2, 6].Value = data[i].Link;
                }
                excel.SaveAs(excelFile);
            }
        }
    }
}

using AngleSharp.Html.Parser;
using SearchJobParser.Class.Model;
using SearchJobParser.Class.Service;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading;

namespace SearchJobParser.Class.Engine
{
    abstract class EngineParser
    {
        private Logger logger = new Logger();
        private protected static Semaphore semaphore = new Semaphore(5, 10, "sync");
        private protected HttpClient client = new HttpClient();
        private protected HtmlParser parser = new HtmlParser();
        private protected static List<ParseData> dataList;
        public event EventHandler<string> ParsingNotification;
        abstract public void ParsingVacancies(string link);
        public List<ParseData> GetParsingData() => dataList;
        public virtual void OnParsingSite(string result) => ParsingNotification?.Invoke(this, result);
        private protected void WriteLogs(string message, MessageType type = MessageType.INFO) => logger.WriteLog(message, type);
    }
}

using AngleSharp.Dom;
using AngleSharp.Html.Dom;
using SearchJobParser.Class.Model;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

namespace SearchJobParser.Class.Engine
{
    internal class EngineHH : EngineParser
    {
        public async override void ParsingVacancies(string link)
        {
            string html = await client.GetStringAsync(link);
            IHtmlDocument document = parser.ParseDocument(html);
            IHtmlCollection<IElement> elements = document.Body.QuerySelectorAll(".magritte-redesign");
            OnParsingSite($"Найдено на HH.RU вакансий: {elements.Length - 1}");
            dataList = new List<ParseData>(elements.Length - 1);
            for (int i = 1; i < elements.Length; i++)
            {
                link = elements[i].QuerySelector("a").GetAttribute("href");
                await Task.Run(() => ParsingPages(link));
            }
            OnParsingSite($"Все спарсил");
        }
        private async void ParsingPages(string link)
        {
            semaphore.WaitOne();
            HttpClient http = new HttpClient();
            string position = null;
            string salary = null;
            string experience = null;
            string worktime = null;
            string format = null;
            StringBuilder description = new StringBuilder();
            try
            {
                string html = await http.GetStringAsync(link);
                IHtmlDocument document = parser.ParseDocument(html);
                IElement element = document.Body.QuerySelector(".vacancy-title");
                position = element.QuerySelector("h1")?.TextContent;
                salary = element.QuerySelector("span")?.TextContent;
                IHtmlCollection<IElement> elements = document.Body.QuerySelectorAll("p");
                for (int i = 0; i < elements.Length; i++)
                {
                    if (elements[i].TextContent.Contains("Опыт работы:"))
                        experience = elements[i].TextContent;
                    else if (elements[i].TextContent.Contains("Формат работы:"))
                        format = elements[i].TextContent;
                    else if (elements[i].TextContent.Contains("График:"))
                    {
                        foreach (IElement elementSpan in elements[i].ParentElement.ChildNodes.QuerySelectorAll("span"))
                        {
                            if (elementSpan.TextContent.Contains("занятость"))
                                worktime = elementSpan.TextContent;
                            else continue;
                        }
                    }
                    else
                        description.AppendLine(elements[i].TextContent.Trim());
                }
                dataList.Add(new ParseData(jobTitle: position, salary: salary,experience: experience, format: format, link: link, worktime: worktime, description: description.ToString()));
                WriteLogs($"Полученны следующие данные:\nПозиция: {position}\nЗарплата: {salary}\n{experience}\n{worktime}\ncсылка: {link}");
                OnParsingSite($"Пропарсил {link}");
            }
            catch (Exception e)
            {
                WriteLogs(e.Message, MessageType.WARN);
            }
            finally
            {
                semaphore.Release();
            }
        }
    }
}

using AngleSharp.Dom;
using AngleSharp.Html.Dom;
using SearchJobParser.Class.Model;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;

namespace SearchJobParser.Class.Engine
{
    internal class EngineSJ : EngineParser
    {
        public async override void ParsingVacancies(string link)
        {
            client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64)");
            string html = await client.GetStringAsync(link);
            IHtmlDocument document = parser.ParseDocument(html);
            IHtmlCollection<IElement> elements = document.Body.QuerySelectorAll(".f-test-search-result-item");
            OnParsingSite($"Найдено на HH.RU вакансий: {elements.Length}");
            dataList = new List<ParseData>(elements.Length);
            for (int i = 1; i < elements.Length; i++)
            {
                if (elements[i].QuerySelector("a")?.GetAttribute("href") == null)
                    continue;
                else
                {
                    link = $"https://russia.superjob.ru{elements[i].QuerySelector("a")?.GetAttribute("href")}";
                    await Task.Run(() => ParsingPages(link));
                }
            }
            OnParsingSite($"Все спарсил");
        }
        private async void ParsingPages(string link)
        {
            semaphore.WaitOne();
            HttpClient http = new HttpClient();
            string position = null;
            string salary = null;
            string experience = null;
            string format = null;
            string description = null;
            try
            {
                http.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64)");
                string html = await http.GetStringAsync(link);
                IHtmlDocument document = parser.ParseDocument(html);
                IElement mainElement = document.Body.QuerySelector("h1");
                position = mainElement.TextContent;
                salary = mainElement.ParentElement.QuerySelector("span").TextContent;
                IElement experienceElement = document.Body.QuerySelector("#app > div > div > div > div > div > div > div > div > div > div > div:nth-child(1) > div > div:nth-child(4) > div > div:nth-child(1) > div > div > span:nth-child(1)");
                experience = experienceElement.TextContent;
                IElement formatElement = document.Body.QuerySelector("#app > div > div > div > div > div > div > div > div > div > div > div:nth-child(1) > div > div:nth-child(4) > div > div:nth-child(1) > div > div > span:nth-child(3)");
                format = formatElement?.TextContent;
                IElement descElement = document.Body.QuerySelector("#app > div > div > div > div > div > div > div > div > div > div > div:nth-child(1) > div > div:nth-child(4) > div > div:nth-child(2)");
                description = descElement?.TextContent;
                dataList.Add(new ParseData(jobTitle: position, salary: salary, experience: experience, format: format, link: link, siteName: JobSiteName.SuperJob, description: description));
                WriteLogs($"Полученны следующие данные:\nПозиция: {position}\nЗарплата: {salary}\n{experience}\ncсылка: {link}");
                OnParsingSite($"Пропарсил {link}");
            }
            catch (Exception e)
            {
                WriteLogs(e.Message, MessageType.WARN);
            }
            finally
            {
                semaphore.Release();
            }
        }
    }
}