using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.Memory;
using NPOI.HPSF;
using NPOI.SS.Formula.Functions;
using Shentun.Pacs.Enums;
using Shentun.Pacs.Models;
using Shentun.Pacs.MyUser;
using Shentun.Pacs.SysParmValues;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Caching;
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;

namespace Shentun.Pacs
{
    public class CacheService : ISingletonDependency
    {
        private readonly IDistributedCache<IdentityUser, Guid> _userCache;
        private readonly IMemoryCache _customerOrgCache;
        //private readonly IDistributedCache<CustomerOrg, Guid> _customerOrgCache;
        private readonly IDistributedCache<string, Guid> _customerOrgTopNameCache;
        private readonly IDistributedCache<Nation, string> _nationCache;
        private readonly IDistributedCache<Sex, char> _sexCache;
        private readonly IDistributedCache<MaritalStatus, char> _maritalStatusCache;
        private readonly IDistributedCache<ForSex, char> _forSexCache;
        private readonly IDistributedCache<DeviceType, Guid> _deviceTypeCache;
        private readonly IDistributedCache<MedicalType, Guid> _medicalTypeCache;
        private readonly IDistributedCache<PersonnelType, Guid> _personnelTypeCache;
        private readonly IMemoryCache _asbitemCache;
        private readonly IMemoryCache _itemTypeCache;
        //private readonly IDistributedCache<ItemType, Guid> _itemTypeCache;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly IRepository<Nation> _nationRepository;
        private readonly IRepository<Sex> _sexRepository;
        private readonly IRepository<ForSex> _forSexRepository;
        private readonly IRepository<DeviceType, Guid> _deviceTypeRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;

        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<MaritalStatus> _maritalStatusRepository;
        private readonly IRepository<MedicalType, Guid> _medicalTypeRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;

        private readonly IDistributedCache<SampleType, Guid> _sampleTypeCache;
        private readonly IRepository<SampleType, Guid> _sampleTypeRepository;

        private readonly SysParmValueManager _sysParmValueManager;

        private readonly IDistributedCache<DiagnosisLevel, short> _diagnosisLevelCache;
        private readonly IRepository<DiagnosisLevel, short> _diagnosisLevelRepository;


        private readonly IDistributedCache<string, string> _customerOrgDisplayModeCache;

        private readonly IMemoryCache _userExtensionCache;

        public CacheService(
            IDistributedCache<IdentityUser, Guid> userCache,
             IMemoryCache customerOrgCache,
            IDistributedCache<Nation, string> nationCache,
             IRepository<IdentityUser, Guid> userRepository,
             IDistributedCache<Sex, char> sexCache,
             IMemoryCache asbitemCache,
             IMemoryCache itemTypeCache,
             IDistributedCache<MaritalStatus, char> maritalStatusCache,
             IDistributedCache<MedicalType, Guid> medicalTypeCache,
             IDistributedCache<PersonnelType, Guid> personnelTypeCache,
        IRepository<Sex> sexRepository,
        IDistributedCache<DeviceType, Guid> deviceTypeCache,
        IRepository<DeviceType, Guid> deviceTypeRepository,
        IDistributedCache<ForSex, char> forSexCache,
        IRepository<ForSex> forSexRepository,
        IRepository<Asbitem, Guid> asbitemRepository,
         IRepository<ItemType, Guid> itemTypeRepository,
        IRepository<Nation> nationRepository,
        IRepository<CustomerOrg, Guid> customerOrgRepository,
        IRepository<MaritalStatus> maritalStatusRepository,
        IRepository<MedicalType, Guid> medicalTypeRepository,
        IRepository<PersonnelType, Guid> personnelTypeRepository,
        IDistributedCache<string, Guid> customerOrgTopNameCache,
        IDistributedCache<SampleType, Guid> sampleTypeCache,
        IRepository<SampleType, Guid> sampleTypeRepository,
        SysParmValueManager sysParmValueManager,
        IDistributedCache<string, string> customerOrgDisplayModeCache,
        IDistributedCache<DiagnosisLevel, short> diagnosisLevelCache,
        IRepository<DiagnosisLevel, short> diagnosisLevelRepository,
        IMemoryCache userExtensionCache)
        {
            _userCache = userCache;
            _userRepository = userRepository;

            _sexCache = sexCache;
            _sexRepository = sexRepository;

            _forSexCache = forSexCache;
            _forSexRepository = forSexRepository;

            _deviceTypeCache = deviceTypeCache;
            _deviceTypeRepository = deviceTypeRepository;

            _asbitemCache = asbitemCache;
            _asbitemRepository = asbitemRepository;

            _itemTypeCache = itemTypeCache;
            _itemTypeRepository = itemTypeRepository;

            _nationCache = nationCache;
            _nationRepository = nationRepository;

            _customerOrgCache = customerOrgCache;
            _customerOrgRepository = customerOrgRepository;

            _maritalStatusCache = maritalStatusCache;
            _maritalStatusRepository = maritalStatusRepository;

            _medicalTypeCache = medicalTypeCache;
            _medicalTypeRepository = medicalTypeRepository;

            _personnelTypeCache = personnelTypeCache;
            _personnelTypeRepository = personnelTypeRepository;
            _customerOrgTopNameCache = customerOrgTopNameCache;
            _sampleTypeCache = sampleTypeCache;
            _sampleTypeRepository = sampleTypeRepository;
            _sysParmValueManager = sysParmValueManager;
            _customerOrgDisplayModeCache = customerOrgDisplayModeCache;
            _diagnosisLevelCache = diagnosisLevelCache;
            _diagnosisLevelRepository = diagnosisLevelRepository;
            _userExtensionCache = userExtensionCache;
        }

        private async Task<IdentityUser> GetUserAsync(Guid id)
        {

            var entity = await _userCache.GetOrAddAsync(
               id, //缓存键
                async () =>
                {
                    var dataEntity = await _userRepository.FirstOrDefaultAsync(m => m.Id == id);

                    //var userSign = dataEntity.GetProperty<string>("user_sign");
                    //var userPhoto = dataEntity.GetProperty<string>("user_photo");
                    //var entDto = new IdentityUserWithExtensionDto
                    //{
                    //    ConcurrencyStamp = dataEntity.ConcurrencyStamp,
                    //    CreationTime = dataEntity.CreationTime,
                    //    CreatorId = dataEntity.CreatorId,
                    //    DeleterId = dataEntity.DeleterId,
                    //    DeletionTime = dataEntity.DeletionTime,
                    //    Email = dataEntity.Email,
                    //    EmailConfirmed = dataEntity.EmailConfirmed,
                    //    Id = dataEntity.Id,
                    //    IsActive = dataEntity.IsActive,
                    //    IsDeleted = dataEntity.IsDeleted,
                    //    LastModificationTime = dataEntity.LastModificationTime,
                    //    LastModifierId = dataEntity.LastModifierId,
                    //    LockoutEnabled = dataEntity.LockoutEnabled,
                    //    LockoutEnd = dataEntity.LockoutEnd,
                    //    Name = dataEntity.Name,
                    //    PhoneNumber = dataEntity.PhoneNumber,
                    //    PhoneNumberConfirmed = dataEntity.PhoneNumberConfirmed,
                    //    Surname = dataEntity.Surname,
                    //    TenantId = dataEntity.TenantId,
                    //    UserName = dataEntity.UserName,
                    //    UserPhoto = userPhoto,
                    //    UserSign = userSign
                    //};
                    return dataEntity;
                }
            );
            return entity;
        }

        public async Task<string> GetSurnameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetUserAsync((Guid)id);
            if (entity != null)
                return entity.Surname;
            else
                return "";
        }

        public async Task<string> GetSurnameAsync(string id)
        {
            Guid newId;

            if (string.IsNullOrWhiteSpace(id) || !Guid.TryParse(id, out newId))
            {
                return "";
            }
            var entity = await GetUserAsync(newId);
            if (entity != null)
                return entity.Surname;
            else
                return "";
        }

        public async Task<string> GetUserSignAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }

            string cacheKey = $"userExtension_{id.ToString()}";

            var userExtension = (IdentityUserWithExtensionDto)_userExtensionCache.Get(cacheKey);
            if (userExtension == null)
            {
                var userEntity = await _userRepository.GetAsync(o => o.Id == id);
                var userSign = userEntity.GetProperty<string>("user_sign");
                var userPhoto = userEntity.GetProperty<string>("user_photo");
                userExtension = new IdentityUserWithExtensionDto
                {
                    ConcurrencyStamp = userEntity.ConcurrencyStamp,
                    CreationTime = userEntity.CreationTime,
                    CreatorId = userEntity.CreatorId,
                    DeleterId = userEntity.DeleterId,
                    DeletionTime = userEntity.DeletionTime,
                    Email = userEntity.Email,
                    EmailConfirmed = userEntity.EmailConfirmed,
                    Id = userEntity.Id,
                    IsActive = userEntity.IsActive,
                    IsDeleted = userEntity.IsDeleted,
                    LastModificationTime = userEntity.LastModificationTime,
                    LastModifierId = userEntity.LastModifierId,
                    LockoutEnabled = userEntity.LockoutEnabled,
                    LockoutEnd = userEntity.LockoutEnd,
                    Name = userEntity.Name,
                    PhoneNumber = userEntity.PhoneNumber,
                    PhoneNumberConfirmed = userEntity.PhoneNumberConfirmed,
                    Surname = userEntity.Surname,
                    TenantId = userEntity.TenantId,
                    UserName = userEntity.UserName,
                    UserPhoto = userPhoto,
                    UserSign = userSign
                };
                _userExtensionCache.Set(cacheKey, userExtension);

            }

            if (userExtension == null)
            {
                return "";
            }
            else
            {
                return userExtension.UserSign;
            }
        }
        private async Task<Sex> GetSexAsync(char id)
        {

            var entity = await _sexCache.GetOrAddAsync(
               id, //缓存键
                async () => (await _sexRepository.GetQueryableAsync()).Where(o => o.Id == id).Single()
            );
            return entity;
        }
        public async Task<string> GetSexNameAsync(char id)
        {

            var entity = await GetSexAsync(id);
            return entity.DisplayName;
        }

        private async Task<ForSex> GetForSexAsync(char id)
        {

            var entity = await _forSexCache.GetOrAddAsync(
               id, //缓存键
                async () => (await _forSexRepository.GetQueryableAsync()).Where(o => o.Id == id).Single()
            );
            return entity;
        }
        public async Task<string> GetForSexNameAsync(char id)
        {

            var entity = await GetForSexAsync(id);
            return entity.DisplayName;
        }

        private async Task<MaritalStatus> GetMaritalStatusAsync(char id)
        {

            var maritalStatusEntity = await _maritalStatusCache.GetAsync(id);
            if (maritalStatusEntity == null)
            {
                maritalStatusEntity = await _maritalStatusRepository.FirstOrDefaultAsync(f => f.Id == id);
            }

            return maritalStatusEntity;

            //var entity = await _maritalStatusCache.GetOrAddAsync(
            //   id, //缓存键
            //    async () => (await _maritalStatusRepository.GetQueryableAsync()).Where(o => o.Id == id).Single()
            //);
            //return entity;
        }
        public async Task<string> GetMaritalStatusNameAsync(char id)
        {

            var entity = await GetMaritalStatusAsync(id);
            return entity.DisplayName;
        }

        private async Task<DeviceType> GetDeviceTypeAsync(Guid id)
        {

            var entity = await _deviceTypeCache.GetOrAddAsync(
               id, //缓存键
                async () => await _deviceTypeRepository.GetAsync(id)

            );
            return entity;
        }
        public async Task<string> GetDeviceTypeNameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetDeviceTypeAsync((Guid)id);
            return entity.DisplayName;
        }

        private async Task<MedicalType> GetMedicalTypeAsync(Guid id)
        {

            var entity = await _medicalTypeCache.GetOrAddAsync(
               id, //缓存键
                async () => await _medicalTypeRepository.GetAsync(id)

            );
            return entity;
        }
        public async Task<string> GetMedicalTypeNameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetMedicalTypeAsync((Guid)id);
            return entity.DisplayName;
        }
        private async Task<PersonnelType> GetPersonnelTypeAsync(Guid id)
        {

            var entity = await _personnelTypeCache.GetOrAddAsync(
               id, //缓存键
                async () => await _personnelTypeRepository.GetAsync(id)

            );
            return entity;
        }
        public async Task<string> GetPersonnelTypeNameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetPersonnelTypeAsync((Guid)id);
            return entity.DisplayName;
        }

        public async Task<Asbitem> GetAsbitemAsync(Guid id)
        {
            var entity = (Asbitem)_asbitemCache.Get(id);
            if (entity == null)
            {
                entity = await _asbitemRepository.GetAsync(o => o.Id == id);
                _asbitemCache.Set(id, entity);
                //entity = (CustomerOrg)_customerOrgCache.Get(id);
            }

            return entity;


            //var entity = await _asbitemCache.GetOrAddAsync(
            //   id, //缓存键
            //    async () => await _asbitemRepository.GetAsync(id)

            //);
            //return entity;
        }

        public async Task<ItemType> GetItemTypeAsync(Guid id)
        {

            var entity = (ItemType)_itemTypeCache.Get(id);
            if (entity == null)
            {
                entity = await _itemTypeRepository.GetAsync(o => o.Id == id);
                _itemTypeCache.Set(id, entity);
                //entity = (CustomerOrg)_customerOrgCache.Get(id);
            }

            //var entity = await _itemTypeCache.GetOrAddAsync(
            //   id, //缓存键
            //    async () => (ItemType) _itemTypeRepository.Get(id)

            //);
            return entity;
        }

        public async Task<Nation> GetNationAsync(string id)
        {

            var entity = await _nationCache.GetOrAddAsync(
               id, //缓存键
                async () => await _nationRepository.GetAsync(o => o.Id == id)

            );
            return entity;
        }

        public async Task<string> GetNationNameAsync(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return "";
            }
            var entity = await GetNationAsync(id);
            return entity.DisplayName;
        }

        /// <summary>
        /// 获取部门名称
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<CustomerOrg> GetCustomerOrgAsync(Guid id)
        {
            var entity = (CustomerOrg)_customerOrgCache.Get(id);
            if (entity == null)
            {
                entity = await _customerOrgRepository.GetAsync(o => o.Id == id);
                _customerOrgCache.Set(id, entity);
                //entity = (CustomerOrg)_customerOrgCache.Get(id);
            }

            return entity;
        }

        /// <summary>
        /// 获取部门名称
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<string> GetCustomerOrgNameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetCustomerOrgAsync((Guid)id);
            return entity.DisplayName;
        }

        /// <summary>
        /// 获取一级单位
        /// </summary>
        /// <param name="id"></param>
        /// <param name="customerOrgDisplayMode">单位显示模式  0-显示一级单位  1-显示上一级单位</param>
        /// <returns></returns>
        public async Task<CustomerOrg> GetTopCustomerOrgAsync(Guid id)
        {
            #region 获取单位显示模式  存缓存
            string customerOrgDisplayMode = _customerOrgDisplayModeCache.Get("customer_org_display_mode");
            if (string.IsNullOrWhiteSpace(customerOrgDisplayMode))
            {
                customerOrgDisplayMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "customer_org_display_mode");
                if (string.IsNullOrWhiteSpace(customerOrgDisplayMode))
                {
                    customerOrgDisplayMode = "0";
                }
                _customerOrgDisplayModeCache.Set("customer_org_display_mode", customerOrgDisplayMode);
            }
            #endregion

            var entity = (CustomerOrg)_customerOrgCache.Get(id);
            if (entity == null)
            {
                entity = await _customerOrgRepository.GetAsync(o => o.Id == id);
                _customerOrgCache.Set(id, entity);
            }

            if (entity.ParentId != null && entity.ParentId != Guid.Empty)
            {
                Guid parentId = (Guid)entity.ParentId;

                if (customerOrgDisplayMode == "0")
                {
                    entity = await GetTopCustomerOrgAsync(parentId);
                }
                else
                {
                    entity = (CustomerOrg)_customerOrgCache.Get(parentId);
                    if (entity == null)
                    {
                        entity = await _customerOrgRepository.GetAsync(o => o.Id == parentId);
                        _customerOrgCache.Set(parentId, entity);
                    }
                }
            }
            return entity;
        }

        /// <summary>
        /// 获取单位简称  一级单位    简称如果没有显示全称
        /// </summary>
        /// <param name="CustomerOrgId"></param>
        /// <returns></returns>
        public async Task<string> GetTopCustomerOrgShortNameAsync(Guid CustomerOrgId)
        {
            var customerOrgEnt = await GetTopCustomerOrgAsync(CustomerOrgId);
            if (string.IsNullOrWhiteSpace(customerOrgEnt.ShortName))
                return customerOrgEnt.DisplayName;
            else
                return customerOrgEnt.ShortName;
        }


        /// <summary>
        /// 获取部门简称      简称如果没有显示全称
        /// </summary>
        /// <param name="CustomerOrgId"></param>
        /// <returns></returns>
        public async Task<string> GetCustomerOrgShortNameAsync(Guid CustomerOrgId)
        {
            var customerOrgEnt = await GetCustomerOrgAsync(CustomerOrgId);
            if (string.IsNullOrWhiteSpace(customerOrgEnt.ShortName))
                return customerOrgEnt.DisplayName;
            else
                return customerOrgEnt.ShortName;
        }

        /// <summary>
        /// 获取所有部门名称
        /// </summary>
        /// <param name="CustomerOrgId"></param>
        /// <returns></returns>
        public async Task<string> GetAllDepartmentNameAsync(Guid CustomerOrgId)
        {
            var departmentDisplayMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "department_display_mode");
            if (departmentDisplayMode == "1")
            {
                List<string> customerOrgNames = new List<string>();
                await GetAllDepartmentNameAsync(customerOrgNames, CustomerOrgId);

                if (customerOrgNames.Count > 1)
                {
                    customerOrgNames.RemoveAt(0);
                    return string.Join("\\", customerOrgNames);
                }
                else
                {
                    //无部门
                    return "";
                }
            }
            else
            {
                //兼容不设置系统参数的
                return await GetCustomerOrgNameAsync(CustomerOrgId);
            }


        }

        /// <summary>
        /// 遍历获取单位数据
        /// </summary>
        /// <param name="customerOrgNames"></param>
        /// <param name="customerOrgId"></param>
        /// <returns></returns>
        public async Task GetAllDepartmentNameAsync(List<string> customerOrgNames, Guid? customerOrgId)
        {
            if (customerOrgId != null)
            {
                var customerOrgEnt = await GetCustomerOrgAsync(customerOrgId.Value);
                if (customerOrgEnt != null)
                {
                    if (string.IsNullOrWhiteSpace(customerOrgEnt.ShortName))
                        customerOrgNames.AddFirst(customerOrgEnt.DisplayName);
                    else
                        customerOrgNames.AddFirst(customerOrgEnt.ShortName);

                    await GetAllDepartmentNameAsync(customerOrgNames, customerOrgEnt.ParentId);
                }
            }
        }

        /// <summary>
        /// 缓存取单位名称   
        /// </summary>
        /// <param name="CustomerOrgId">部门ID</param>
        /// <returns></returns>
        public async Task<string> GetTopCustomerOrgNameAsync(Guid CustomerOrgId)
        {
            string topCustomerOrgName = await _customerOrgTopNameCache.GetOrAddAsync(
            CustomerOrgId, //缓存键
               async () => await GetTopCustomerOrgNameInCustomerOrgIdAsync(CustomerOrgId)

           );

            return topCustomerOrgName;
        }

        /// <summary>
        /// 根据部门ID 按PathCode码查询单位名称
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private async Task<string> GetTopCustomerOrgNameInCustomerOrgIdAsync(Guid id)
        {
            #region 获取单位显示模式  存缓存
            string customerOrgDisplayMode = _customerOrgDisplayModeCache.Get("customer_org_display_mode");
            if (string.IsNullOrWhiteSpace(customerOrgDisplayMode))
            {
                customerOrgDisplayMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "customer_org_display_mode");
                if (string.IsNullOrWhiteSpace(customerOrgDisplayMode))
                {
                    customerOrgDisplayMode = "0";
                }
                _customerOrgDisplayModeCache.Set("customer_org_display_mode", customerOrgDisplayMode);
            }
            #endregion

            var entity = (CustomerOrg)_customerOrgCache.Get(id);
            if (entity == null)
            {
                entity = await _customerOrgRepository.GetAsync(o => o.Id == id);
                _customerOrgCache.Set(id, entity);
            }


            if (entity.Id == GuidFlag.PersonCustomerOrgId)
            {
                return entity.DisplayName;
            }
            if (entity.PathCode.Length == 5)
            {
                return entity.DisplayName;
            }

            if (customerOrgDisplayMode == "0")
            {
                entity = await _customerOrgRepository.GetAsync(o => o.PathCode == entity.PathCode.Substring(0, 5));
            }
            else
            {
                entity = await _customerOrgRepository.GetAsync(o => o.Id == entity.ParentId);
            }
            return entity.DisplayName;
        }

        /// <summary>
        /// 获取顶级单位ID  直取，不按配置来，用登记界面做单位比较
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Guid> GetTopCustomerOrgIdAsync(Guid id)
        {
            Guid topCustomerOrgId = id;


            var entity = (CustomerOrg)_customerOrgCache.Get(id);
            if (entity == null)
            {
                entity = await _customerOrgRepository.GetAsync(o => o.Id == id);
                _customerOrgCache.Set(id, entity);
            }

            if (entity.PathCode.Length > 5)
            {
                entity = await _customerOrgRepository.GetAsync(o => o.PathCode == entity.PathCode.Substring(0, 5));
                topCustomerOrgId = entity.Id;
            }


            return topCustomerOrgId;
        }


        private async Task<SampleType> GetSampleTypeAsync(Guid id)
        {

            var entity = await _sampleTypeCache.GetOrAddAsync(
               id, //缓存键
                async () => await _sampleTypeRepository.GetAsync(id)

            );
            return entity;
        }
        public async Task<string> GetSampleTypeNameAsync(Guid? id)
        {
            if (id == null || id == default(Guid) || !id.HasValue)
            {
                return "";
            }
            var entity = await GetSampleTypeAsync((Guid)id);
            return entity.DisplayName;
        }

        /// <summary>
        /// 获取诊断级别名称
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<string> GetDiagnosisLevelNameAsync(short? id)
        {
            if (id != null)
            {
                var diagnosisLevelEntity = await _diagnosisLevelCache.GetAsync(id.Value);
                if (diagnosisLevelEntity == null)
                {
                    diagnosisLevelEntity = await _diagnosisLevelRepository.FirstOrDefaultAsync(f => f.Id == id);
                }

                return diagnosisLevelEntity.DisplayName;
            }
            else
            {
                return "";
            }


        }

    }
}