HRM_RabbitMQ_Consumer/JSONParser/Program.cs

// See https://aka.ms/new-console-template for more information
using JSONParser;
using JSONParser.Logger;
using JSONParser.QDocWrapper;
using Newtonsoft.Json.Linq;
using RabbitMQ.Client.Events;
using RabbitMQ.Client;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.Extensions.Configuration;

public static class Program
{
    public async static Task Main(string[] args)
    {
        await LaunchConsumer();
    }

    private static async Task LaunchConsumer()
    {
        var builder = new ConfigurationBuilder()
                        .SetBasePath(Directory.GetCurrentDirectory())
                        .AddJsonFile("config.json", optional: false);
        IConfiguration config = builder.Build();

        Console.OutputEncoding = Encoding.UTF8;

        var odata = new ODataAccess(config);
        var odataClient = odata.Client;

        //using ILoggerFactory factory = LoggerFactory.Create(builder => builder.AddConsole());
        //ILogger logger = factory.CreateLogger("HRM_MQ");

        var logger = new Logger("HRM_MQ", @"C:\log");

        var wrapper = new QDocWrapper(odataClient, logger);

        var rabbitFactory = new ConnectionFactory
        {
            HostName = config["RabbitSettings:HostName"],
            UserName = config["RabbitSettings:UserName"],
            Password = config["RabbitSettings:Password"],
            VirtualHost = config["RabbitSettings:VirtualHost"]
        };

        var connection = await rabbitFactory.CreateConnectionAsync();
        var channel = await connection.CreateChannelAsync();

        await channel.QueueDeclareAsync(
            queue: config["RabbitSettings:ChannelName"],
            durable: false,
            exclusive: false,
            autoDelete: false,
            arguments: null);
        var consumer = new AsyncEventingBasicConsumer(channel);
        consumer.ReceivedAsync += async (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);
            var jarray = JArray.Parse(message);
            await CreateFromJArray(odataClient, logger, wrapper, jarray);
            //Console.WriteLine($" [x] Received {message}");
            await Task.Yield();
        };
        await channel.BasicConsumeAsync(
            queue: config["RabbitSettings:ChannelName"],
            autoAck: true,
            consumer: consumer);

        while (true)
        {

        }
    }

    static async Task<JArray> GetArrayFromService()
    {
        JArray array = [];
        using (var client = new HttpClient())
        {
            var byteArray = Encoding.ASCII.GetBytes("QDoc:Xe3xihuz");
            client.Timeout = new TimeSpan(0, 10, 0);
            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            HttpResponseMessage response = await client.GetAsync("http://ast1c/HRMkz31/hs/qdoc/staff");
            await client.DeleteAsync("http://ast1c/HRMkz31/hs/qdoc/staff");
            string responseBody = await response.Content.ReadAsStringAsync();
            array = JArray.Parse(responseBody);
        }
        return array;
    }

    static async Task CreateFromJArray(Simple.OData.Client.ODataClient? odataClient, Logger logger, QDocWrapper wrapper, JArray jarray)
    {
        var structure = new JSONStructure(jarray);

        foreach (var businessUnit in structure.BusinessUnits)
        {
            var id = await wrapper.CreateBusinessUnit(businessUnit);
        }

        foreach (var department in structure.Departments)
        {
            var id = await wrapper.CreateDepartment(department);
        }

        foreach (var jobTitle in structure.JobTitles)
        {
            var id = await wrapper.CreateJobTitle(jobTitle);
        }

        foreach (var employee in structure.Employees)
        {
            try
            {
                var id = await wrapper.CreateEmployee(employee);
            }
            catch (Exception)
            {
                logger.Error($"{employee.Type} - {employee.Sid} - Failed to create");
            }
        }

        foreach (var businessUnit in structure.BusinessUnits)
        {
            var ceoId = await businessUnit.CreateNCEO(odataClient);
            if (ceoId > 0)
            {
                logger.Info($"{businessUnit.Type} - {businessUnit.Sid} - CEO_Created");
            }
            else
            {
                logger.Warn($"{businessUnit.Type} - {businessUnit.Sid} - CEO_Skip");
                if (businessUnit.NCEO != null && businessUnit.NCEO.Sid != null)
                {
                    logger.Warn($"Сотрудники - {businessUnit.NCEO.Sid} - Skipped_CEO_Sid");
                }
            }
            var accountId = await businessUnit.CreateAccount(odataClient);
            if (accountId > 0)
            {
                logger.Info($"{businessUnit.Type} - {businessUnit.Sid} - Account_Created");
            }
            else
            {
                logger.Warn($"{businessUnit.Type} - {businessUnit.Sid} - Account_Skip");
                if (businessUnit.Account != null && businessUnit.Account.Sid != null)
                {
                    logger.Warn($"Сотрудники - {businessUnit.Account.Sid} - Skipped_Account_Sid");
                }
            }
        }
    }
}