у меня был такой сервис
```
// Services/ImportService.cs

using AutoMapper;
using BuildingFlow.Data.Contract;
using BuildingFlow.Data.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace BuildingFlow.Services.CostImportService
{
    public class ImportService
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly IMapper _mapper;
        private readonly ILogger<ImportService> _logger;

        public ImportService(IUnitOfWork unitOfWork, IMapper mapper, ILogger<ImportService> logger)
        {
            _unitOfWork = unitOfWork;
            _mapper = mapper;
            _logger = logger;
        }

        public async Task ImportCostItemsAsync()
        {
            await _unitOfWork.BeginTransactionAsync();
            try
            {
                var costItemsRepository = _unitOfWork.GetRepository<CostItem>();
                var costsRepository = _unitOfWork.GetRepository<Cost>();
                var projectsRepository = _unitOfWork.GetRepository<Project>();
                var costTypesRepository = _unitOfWork.GetRepository<CostType>();
                var unitsRepository = _unitOfWork.GetRepository<Unit>();
                var materialsRepository = _unitOfWork.GetRepository<Material>();
                var projectWorkStagesRepository = _unitOfWork.GetRepository<ProjectWorkStage>();
                //var worksRepository = _unitOfWork.GetRepository<Work>();

                // Получаем все записи из старой таблицы, отсортированные по уровню иерархии
                var costItems = await costItemsRepository.AsQueryable()
                    .OrderBy(c => c.HierarchyLevel)
                    .ToListAsync();

                // Словарь для сопоставления старых Id с новыми CostId
                var idMap = new Dictionary<int, int>();

                foreach (var costItem in costItems)
                {
                    // Пропускаем уже импортированные записи
                    if (costItem.IsMigrated)
                    {
                        _logger.LogInformation($"Запись Id {costItem.Id} уже импортирована. Пропуск.");
                        continue;
                    }

                    try
                    {
                        // 1. Обработка Project
                        Project project = null;
                        if (costItem.ProjectId != 0) // Проверка на валидный ProjectId
                        {
                            project = await projectsRepository.AsQueryable()
                                .FirstOrDefaultAsync(p => p.Id == costItem.ProjectId);

                            if (project == null)
                            {
                                // Создаем новый проект, если не найден
                                project = new Project
                                {
                                    Id = costItem.ProjectId,
                                    //Title = $"Project {costItem.ProjectId}" // Настройте логику именования
                                    ////// Заполните другие поля проекта, если есть
                                };
                                projectsRepository.Create(project);
                                await _unitOfWork.SaveChangesAsync();
                                _logger.LogInformation($"Создан новый проект: {project.Id}");
                            }
                        }
                        else
                        {
                            _logger.LogWarning($"Запись Id {costItem.Id} имеет неверный ProjectId.");
                            continue; // Пропускаем запись или можно обработать иначе
                        }

                        // 2. Обработка CostType
                        var costType = await costTypesRepository.AsQueryable()
                            .FirstOrDefaultAsync(ct => ct.TypeName == costItem.TypeCost);

                        if (costType == null)
                        {
                            costType = new CostType
                            {
                                TypeName = costItem.TypeCost
                            };
                            costTypesRepository.Create(costType);
                            await _unitOfWork.SaveChangesAsync();
                            _logger.LogInformation($"Создан новый тип затрат: {costType.TypeName}");
                        }

                        // 3. Обработка Unit
                        Unit unit = null;
                        if (!string.IsNullOrWhiteSpace(costItem.UnitOfMeasure))
                        {
                            unit = await unitsRepository.AsQueryable()
                                .FirstOrDefaultAsync(u => u.UnitName == costItem.UnitOfMeasure);

                            if (unit == null)
                            {
                                unit = new Unit
                                {
                                    UnitName = costItem.UnitOfMeasure,
                                    UnitDescription = "" // Заполните при необходимости
                                };
                                unitsRepository.Create(unit);
                                await _unitOfWork.SaveChangesAsync();
                                _logger.LogInformation($"Создана новая единица измерения: {unit.UnitName}");
                            }
                        }

                        // 4. Обработка ParentCost
                        int? parentCostId = null;
                        if (costItem.ParentId.HasValue)
                        {
                            if (idMap.TryGetValue(costItem.ParentId.Value, out int newParentCostId))
                            {
                                parentCostId = newParentCostId;
                            }
                            else
                            {
                                _logger.LogWarning($"ParentId {costItem.ParentId.Value} не найден для записи Id {costItem.Id}. Запись пропущена.");
                                continue; // Пропускаем запись или можно обработать иначе
                            }
                        }

                        // 5. Создание новой записи Cost
                        var cost = _mapper.Map<Cost>(costItem);
                        cost.ProjectId = project.Id;
                        cost.ParentCostId = parentCostId;
                        cost.CostTypeId = costType.CostTypeId;
                        cost.UnitId = unit?.UnitId;

                        costsRepository.Create(cost);
                        await _unitOfWork.SaveChangesAsync();

                        _logger.LogInformation($"Создана новая затрата: {cost.CostName} (NumberItem: {cost.NumberItem})");

                        // Обновление словаря
                        idMap[costItem.Id] = cost.CostId;

                        // 6. Создание записи Material или Work
                        if (costItem.TypeCost.Equals("Материал", StringComparison.OrdinalIgnoreCase))
                        {
                            var material = new Material
                            {
                                CostId = cost.CostId
                                // Добавьте дополнительные поля, если необходимо
                            };
                            materialsRepository.Create(material);
                            _logger.LogInformation($"Создан материал для затрат: {cost.CostName}");
                        }
                        else if (costItem.TypeCost.Equals("Работа", StringComparison.OrdinalIgnoreCase))
                        {
                            var work = new _Work
                            {
                                CostId = cost.CostId
                                // Добавьте дополнительные поля, если необходимо
                            };
                            worksRepository.Create(work);
                            _logger.LogInformation($"Создана работа для затрат: {cost.CostName}");
                        }

                        // 7. Установка флага миграции
                        costItem.IsMigrated = true;
                        //costItemsRepository.Update(costItem);

                        // Сохраняем изменения
                        await _unitOfWork.SaveChangesAsync();
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, $"Ошибка при обработке записи Id {costItem.Id}");
                        // Приезжая ошибка может прервать весь процесс из-за транзакции
                        throw;
                    }
                }

                // Завершение транзакции
                await _unitOfWork.CommitAsync();
                _logger.LogInformation("Миграция данных завершена успешно.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Ошибка при миграции данных. Произошёл откат транзакции.");
                await _unitOfWork.RollbackAsync();
                throw; // Перебрасываем ошибку выше, если необходимо
            }
        }
    }
}
```
перепиши код под новую структуру данных