parr_api/PARR.DAL/DomainServices/Implementations/ShortcodesService.cs

using Microsoft.EntityFrameworkCore;
using PARR.DAL.Contracts;
using PARR.DAL.DomainServices.Interfaces;
using PARR.DAL.Services.Interfaces.Job;
using PARR.DAL.Services.Interfaces.Unit;
using System.Text.RegularExpressions;

namespace PARR.DAL.DomainServices.Implementations
{
    internal class ShortcodesService : IShortcodesService
    {
        private const string shortcodePattern = "%[^%\\s]+%";
        private readonly SettingsFromDb settingsFromDb;
        private readonly IJobService jobService;
        private readonly IUnitService unitService;

        public ShortcodesService(
            SettingsFromDb settingsFromDb,
            IJobService jobService,
            IUnitService unitService
            )
        {
            this.settingsFromDb = settingsFromDb;
            this.jobService = jobService;
            this.unitService = unitService;
        }

        public async Task<string> ApplyShortcodesAsync(string str, Guid unitId, Guid jobId)
        {
            //TODO удалить старый в GeneralExtesions, связанные с ним Enum и написать метод. делов...

            var nameConstants = settingsFromDb.TemplateNameConstantPartsList;

            var job = await jobService
                                .Get().AsNoTracking()
                                .Include(t=>t.Tnk)
                                .Include(t=>t.Group)
                                .FirstOrDefaultAsync(t => t.Id == jobId);

            var unit = await unitService.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Id == unitId);

            if (job != null && unit != null && job.TemplateNameMask != null)
            {
                var resultName = str;

                var shortcodesInMask = GetShortCodes(resultName);

                //Проверяем и меняем наличие статичных частей в маске имени шаблона
                if (shortcodesInMask.Any(x => nameConstants.Select(x => "%" + x.Name + "%").ToList().Contains(x.Value)))
                {
                    resultName = ReplaceConstants(nameConstants, resultName);
                }

                //Проверяем и меняем Shortcodes в маске имени шаблона
                var shortCodes = GetShortcodesNames();
                if (shortcodesInMask.Any(x => shortCodes.Select(x => x).ToList().Contains(x.Value)))
                {
                    resultName = ReplaceShortcodes(job, unit, resultName, shortcodesInMask);
                }

                //Если остались %переменные% проверяем совпадение по имени поля
                shortcodesInMask = GetShortCodes(resultName);
                if (shortcodesInMask.Count > 0)
                {
                    resultName = await ReplaceFieldValues(unitId, resultName, shortcodesInMask);
                }

                return resultName;
            }

            return "";
        }


        public bool isAnyShortcodes(string str)
        {
            return Regex.IsMatch(str, shortcodePattern);
        }


        private async Task<string> ReplaceFieldValues(Guid unitId, string resultName, List<Match> shortcodesInMask)
        {
            var unitWithFields = await unitService.Get()
                .AsNoTracking()
                .Include(u => u.UnitValues)
                    .ThenInclude(uv => uv.Field)
                .Include(u => u.UnitValues)
                    .ThenInclude(uv => uv.Value)
                .FirstOrDefaultAsync(t => t.Id == unitId);

            foreach (var item in shortcodesInMask)
            {
                var fieldName = item.Value.Replace("%", "").ToUpper();

                var value = unitWithFields!.UnitValues!.FirstOrDefault(t => t.Field!.AihitName!.ToUpper() == fieldName!);

                if (value != null)
                    resultName = resultName.Replace(item.Value, value!.Value!.Value);
            }

            return resultName;
        }


        private static string ReplaceShortcodes(Models.Job.Job job, Models.Unit.Unit unit, string resultName, List<Match> shortcodesInMask)
        {
            if (shortcodesInMask.Any(x => x.Value == "%ЭК%"))
                resultName = resultName.Replace("%ЭК%", unit.Name);

            if (shortcodesInMask.Any(x => x.Value == "%ГРУППА_РАБОТ%"))
                resultName = resultName.Replace("%ГРУППА_РАБОТ%", job.Group!.GroupName);

            if (shortcodesInMask.Any(x => x.Value == "%РАБОТА%"))
                resultName = resultName.Replace("%РАБОТА%", job.WorkName);

            if (shortcodesInMask.Any(x => x.Value == "%ТНК%"))
                resultName = resultName.Replace("%ТНК%", job.Tnk!.Name);

            return resultName;
        }


        private static string ReplaceConstants(List<BLL.Domain.TemplateNameConstantPart> nameConstants, string resultName)
        {
            foreach (var item in nameConstants)
            {
                resultName = resultName.Replace($"%{item.Name}%", item.Value);
            }

            return resultName;
        }


        private static List<Match> GetShortCodes(string resultName)
        {
            var shortcodesInMask = Regex.Matches(resultName, shortcodePattern).ToList();
            return shortcodesInMask;
        }

        private List<string> GetShortcodesNames()
        {
            var result = new List<string> {
                "%ЭК%",
                "%ГРУППА_РАБОТ%",
                "%РАБОТА%",
                "%ТНК%"
            };

            return result;
        }
    }
}