1011 lines
35 KiB
C#
1011 lines
35 KiB
C#
using System;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text.Json;
|
||
using System.Threading.Tasks;
|
||
using Kurs.Languages.Entities;
|
||
using Kurs.Notifications.Entities;
|
||
using Kurs.Platform.Entities;
|
||
using Kurs.Platform.Enums;
|
||
using Kurs.Platform.Forum;
|
||
using Kurs.Platform.Seeds;
|
||
using Kurs.Settings.Entities;
|
||
using Microsoft.Extensions.Configuration;
|
||
using Volo.Abp.Data;
|
||
using Volo.Abp.DependencyInjection;
|
||
using Volo.Abp.Domain.Repositories;
|
||
using Volo.Abp.MultiTenancy;
|
||
using Volo.Abp.PermissionManagement;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using EFCore.BulkExtensions;
|
||
using System.Collections.Generic;
|
||
using Kurs.Platform.Contacts;
|
||
using static Kurs.Settings.SettingsConsts;
|
||
|
||
namespace Kurs.Platform.Data.Seeds;
|
||
|
||
public class PlatformDataSeeder : IDataSeedContributor, ITransientDependency
|
||
{
|
||
private readonly IRepository<Language, Guid> _languages;
|
||
private readonly IRepository<LanguageKey, Guid> _languageKey;
|
||
private readonly IRepository<LanguageText, Guid> _languagesText;
|
||
private readonly IRepository<DataSource, Guid> _dataSources;
|
||
private readonly IRepository<SettingDefinition, Guid> _settings;
|
||
private readonly IRepository<GlobalSearch, int> _globalSearch;
|
||
private readonly IRepository<BackgroundWorker, Guid> _backgroundWorkerRepository;
|
||
private readonly IRepository<NotificationRule, Guid> _notificationRuleRepository;
|
||
private readonly IRepository<Menu, Guid> _menuRepository;
|
||
private readonly IRepository<PermissionGroupDefinitionRecord, Guid> _permissionGroupRepository;
|
||
private readonly IRepository<PermissionDefinitionRecord, Guid> _permissionRepository;
|
||
private readonly IRepository<Sector, Guid> _sectorRepository;
|
||
private readonly IRepository<UomCategory, Guid> _uomCategoryRepository;
|
||
private readonly IRepository<Uom, Guid> _uomRepository;
|
||
private readonly IRepository<Currency, Guid> _currencyRepository;
|
||
private readonly IRepository<CountryGroup, Guid> _countryGroupRepository;
|
||
private readonly IRepository<Country, Guid> _countryRepository;
|
||
private readonly IRepository<City, Guid> _cityRepository;
|
||
private readonly IRepository<District, Guid> _districtRepository;
|
||
private readonly IRepository<SkillType, Guid> _skillTypeRepository;
|
||
private readonly IRepository<Skill, Guid> _skillRepository;
|
||
private readonly IRepository<SkillLevel, Guid> _skillLevelRepository;
|
||
private readonly IRepository<ContactTag, Guid> _contactTagRepository;
|
||
private readonly IRepository<ContactTitle, Guid> _contactTitleRepository;
|
||
private readonly IRepository<BlogCategory, Guid> _blogCategoryRepository;
|
||
private readonly IRepository<BlogPost, Guid> _blogPostsRepository;
|
||
private readonly IRepository<ForumCategory, Guid> _forumCategoryRepository;
|
||
private readonly IRepository<AiBot, Guid> _aiBotRepository;
|
||
private readonly IRepository<Route, Guid> _routeRepository;
|
||
private readonly IRepository<CustomEndpoint, Guid> _customEndpointRepository;
|
||
private readonly IRepository<Product, Guid> _productRepository;
|
||
private readonly IRepository<PaymentMethod, String> _paymentMethodRepository;
|
||
private readonly IRepository<InstallmentOption, Guid> _installmentOptionRepository;
|
||
private readonly IRepository<CustomComponent, Guid> _customComponentRepository;
|
||
private readonly IRepository<ReportCategory, Guid> _reportCategoriesRepository;
|
||
private readonly IRepository<Service, Guid> _servicesRepository;
|
||
private readonly IRepository<About, Guid> _aboutRepository;
|
||
private readonly IRepository<Contact, Guid> _contactRepository;
|
||
private readonly IRepository<Classroom, Guid> _classroomRepository;
|
||
|
||
public PlatformDataSeeder(
|
||
IRepository<Language, Guid> languages,
|
||
IRepository<LanguageKey, Guid> languageKey,
|
||
IRepository<LanguageText, Guid> languagesText,
|
||
IRepository<DataSource, Guid> dataSource,
|
||
IRepository<SettingDefinition, Guid> settings,
|
||
IRepository<GlobalSearch, int> globalSearch,
|
||
IRepository<BackgroundWorker, Guid> backgroundWorkerRepository,
|
||
IRepository<NotificationRule, Guid> notificationRuleRepository,
|
||
IRepository<Menu, Guid> menuRepository,
|
||
IRepository<PermissionGroupDefinitionRecord, Guid> permissionGroupRepository,
|
||
IRepository<PermissionDefinitionRecord, Guid> permissionRepository,
|
||
IRepository<Sector, Guid> sectorRepository,
|
||
IRepository<UomCategory, Guid> uomCategoryRepository,
|
||
IRepository<Uom, Guid> uomRepository,
|
||
IRepository<Currency, Guid> currencyRepository,
|
||
IRepository<CountryGroup, Guid> countryGroupRepository,
|
||
IRepository<Country, Guid> countryRepository,
|
||
IRepository<City, Guid> cityRepository,
|
||
IRepository<District, Guid> districtRepository,
|
||
IRepository<SkillType, Guid> skillTypeRepository,
|
||
IRepository<Skill, Guid> skillRepository,
|
||
IRepository<SkillLevel, Guid> skillLevelRepository,
|
||
IRepository<ContactTag, Guid> contactTagRepository,
|
||
IRepository<ContactTitle, Guid> contactTitleRepository,
|
||
IRepository<BlogCategory, Guid> blogCategoryRepository,
|
||
IRepository<BlogPost, Guid> blogPostsRepository,
|
||
IRepository<ForumCategory, Guid> forumCategoryRepository,
|
||
IRepository<AiBot, Guid> aiBotRepository,
|
||
IRepository<Route, Guid> routeRepository,
|
||
IRepository<CustomEndpoint, Guid> customEndpointRepository,
|
||
IRepository<Product, Guid> productRepository,
|
||
IRepository<PaymentMethod, String> paymentMethodRepository,
|
||
IRepository<InstallmentOption, Guid> installmentOptionRepository,
|
||
IRepository<CustomComponent, Guid> customComponentRepository,
|
||
IRepository<ReportCategory, Guid> reportCategoriesRepository,
|
||
IRepository<Service, Guid> servicesRepository,
|
||
IRepository<About, Guid> aboutRepository,
|
||
IRepository<Contact, Guid> contactRepository,
|
||
IRepository<Classroom, Guid> classroomRepository
|
||
)
|
||
{
|
||
_languages = languages;
|
||
_languageKey = languageKey;
|
||
_languagesText = languagesText;
|
||
_dataSources = dataSource;
|
||
_settings = settings;
|
||
_globalSearch = globalSearch;
|
||
_backgroundWorkerRepository = backgroundWorkerRepository;
|
||
_notificationRuleRepository = notificationRuleRepository;
|
||
_menuRepository = menuRepository;
|
||
_permissionGroupRepository = permissionGroupRepository;
|
||
_permissionRepository = permissionRepository;
|
||
_sectorRepository = sectorRepository;
|
||
_uomCategoryRepository = uomCategoryRepository;
|
||
_uomRepository = uomRepository;
|
||
_currencyRepository = currencyRepository;
|
||
_countryGroupRepository = countryGroupRepository;
|
||
_countryRepository = countryRepository;
|
||
_cityRepository = cityRepository;
|
||
_districtRepository = districtRepository;
|
||
_skillTypeRepository = skillTypeRepository;
|
||
_skillRepository = skillRepository;
|
||
_skillLevelRepository = skillLevelRepository;
|
||
_contactTagRepository = contactTagRepository;
|
||
_contactTitleRepository = contactTitleRepository;
|
||
_blogCategoryRepository = blogCategoryRepository;
|
||
_blogPostsRepository = blogPostsRepository;
|
||
_forumCategoryRepository = forumCategoryRepository;
|
||
_aiBotRepository = aiBotRepository;
|
||
_routeRepository = routeRepository;
|
||
_customEndpointRepository = customEndpointRepository;
|
||
_productRepository = productRepository;
|
||
_paymentMethodRepository = paymentMethodRepository;
|
||
_installmentOptionRepository = installmentOptionRepository;
|
||
_customComponentRepository = customComponentRepository;
|
||
_reportCategoriesRepository = reportCategoriesRepository;
|
||
_servicesRepository = servicesRepository;
|
||
_aboutRepository = aboutRepository;
|
||
_contactRepository = contactRepository;
|
||
_classroomRepository = classroomRepository;
|
||
}
|
||
|
||
private static IConfigurationRoot BuildConfiguration()
|
||
{
|
||
var builder = new ConfigurationBuilder()
|
||
.SetBasePath(Directory.GetCurrentDirectory())
|
||
.AddJsonFile("appsettings.json")
|
||
.AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? ""}.json", true);
|
||
|
||
return builder.Build();
|
||
}
|
||
|
||
|
||
public async Task SeedCountyGroupsAsync()
|
||
{
|
||
var dbCtx = await _countryRepository.GetDbContextAsync();
|
||
|
||
// DB’de mevcut kodları set olarak al
|
||
var existingCodes = (await dbCtx.Set<CountryGroup>()
|
||
.Select(c => c.Name)
|
||
.ToListAsync())
|
||
.ToHashSet();
|
||
|
||
var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
|
||
|
||
using var fs = File.OpenRead(Path.Combine("Seeds", "CountryGroups.json"));
|
||
|
||
var buffer = new List<CountryGroup>(capacity: 1000);
|
||
var seenCodes = new HashSet<string>(); // JSON içindeki duplicate’leri yakalamak için
|
||
|
||
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable<CountryGroupDto>(fs, options))
|
||
{
|
||
if (item == null) continue;
|
||
if (string.IsNullOrWhiteSpace(item.Name)) continue; // boş kodları atla
|
||
|
||
// hem DB’de hem JSON içinde duplicate engelle
|
||
if (!seenCodes.Add(item.Name) || existingCodes.Contains(item.Name))
|
||
continue;
|
||
|
||
buffer.Add(new CountryGroup(
|
||
Guid.NewGuid(),
|
||
item.Name
|
||
));
|
||
|
||
if (buffer.Count >= 1000)
|
||
{
|
||
await BulkCountryGroupInsertAsync(buffer);
|
||
buffer.Clear();
|
||
}
|
||
}
|
||
|
||
if (buffer.Count > 0)
|
||
{
|
||
await BulkCountryGroupInsertAsync(buffer);
|
||
}
|
||
}
|
||
|
||
private async Task BulkCountryGroupInsertAsync(List<CountryGroup> entities)
|
||
{
|
||
var dbCtx = await _countryGroupRepository.GetDbContextAsync();
|
||
await dbCtx.BulkInsertAsync(entities, new BulkConfig
|
||
{
|
||
BatchSize = 1000
|
||
});
|
||
}
|
||
|
||
public async Task SeedCountriesAsync()
|
||
{
|
||
var dbCtx = await _countryRepository.GetDbContextAsync();
|
||
|
||
// DB’de mevcut kodları set olarak al
|
||
var existingCodes = (await dbCtx.Set<Country>()
|
||
.Select(c => c.Code)
|
||
.ToListAsync())
|
||
.ToHashSet();
|
||
|
||
var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
|
||
|
||
using var fs = File.OpenRead(Path.Combine("Seeds", "Countries.json"));
|
||
|
||
var buffer = new List<Country>(capacity: 1000);
|
||
var seenCodes = new HashSet<string>(); // JSON içindeki duplicate’leri yakalamak için
|
||
|
||
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable<CountryDto>(fs, options))
|
||
{
|
||
if (item == null) continue;
|
||
if (string.IsNullOrWhiteSpace(item.Code)) continue; // boş kodları atla
|
||
|
||
// hem DB’de hem JSON içinde duplicate engelle
|
||
if (!seenCodes.Add(item.Code) || existingCodes.Contains(item.Code))
|
||
continue;
|
||
|
||
buffer.Add(new Country(
|
||
Guid.NewGuid(),
|
||
item.Code,
|
||
item.Name,
|
||
item.GroupName,
|
||
item.CurrencyCode,
|
||
item.PhoneCode,
|
||
item.TaxLabel
|
||
));
|
||
|
||
if (buffer.Count >= 1000)
|
||
{
|
||
await BulkCountryInsertAsync(buffer);
|
||
buffer.Clear();
|
||
}
|
||
}
|
||
|
||
if (buffer.Count > 0)
|
||
{
|
||
await BulkCountryInsertAsync(buffer);
|
||
}
|
||
}
|
||
|
||
private async Task BulkCountryInsertAsync(List<Country> entities)
|
||
{
|
||
var dbCtx = await _countryRepository.GetDbContextAsync();
|
||
await dbCtx.BulkInsertAsync(entities, new BulkConfig
|
||
{
|
||
BatchSize = 1000
|
||
});
|
||
}
|
||
|
||
public async Task SeedCitiesAsync()
|
||
{
|
||
var dbCtx = await _cityRepository.GetDbContextAsync();
|
||
|
||
// 1. Mevcut kayıtları çek (tek sorguda)
|
||
var existingCities = await dbCtx.Set<City>()
|
||
.Select(d => new { d.Code })
|
||
.ToListAsync();
|
||
|
||
var existingSet = existingCities
|
||
.Select(d => d.Code)
|
||
.ToHashSet();
|
||
|
||
var options = new JsonSerializerOptions
|
||
{
|
||
PropertyNameCaseInsensitive = true
|
||
};
|
||
|
||
// 2. JSON’u stream et
|
||
using FileStream fs = File.OpenRead(Path.Combine("Seeds", "Cities.json"));
|
||
|
||
var buffer = new List<City>(capacity: 5000);
|
||
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable<CityDto>(fs, options))
|
||
{
|
||
if (item == null) continue;
|
||
|
||
var key = $"{item.Country}.{item.Code}";
|
||
if (existingSet.Contains(key)) continue; // duplicate kontrolü
|
||
|
||
buffer.Add(new City(
|
||
Guid.NewGuid(),
|
||
item.Country,
|
||
item.Name,
|
||
key,
|
||
item.PlateCode
|
||
));
|
||
|
||
if (buffer.Count >= 1000) // 3. Batch
|
||
{
|
||
await BulkCityInsertAsync(buffer);
|
||
buffer.Clear();
|
||
}
|
||
}
|
||
|
||
if (buffer.Count > 0)
|
||
{
|
||
await BulkCityInsertAsync(buffer);
|
||
}
|
||
}
|
||
|
||
private async Task BulkCityInsertAsync(List<City> entities)
|
||
{
|
||
var dbCtx = await _cityRepository.GetDbContextAsync();
|
||
await dbCtx.BulkInsertAsync(entities, new BulkConfig
|
||
{
|
||
PreserveInsertOrder = true,
|
||
SetOutputIdentity = true,
|
||
BatchSize = 1000
|
||
});
|
||
}
|
||
|
||
public async Task SeedDistrictsAsync()
|
||
{
|
||
var dbCtx = await _districtRepository.GetDbContextAsync();
|
||
|
||
// 1. Mevcut kayıtları çek (tek sorguda)
|
||
var existingDistricts = await dbCtx.Set<District>()
|
||
.Select(d => new { d.Country, d.City, d.Name, d.Township, d.Street, d.ZipCode })
|
||
.ToListAsync();
|
||
|
||
var existingSet = existingDistricts
|
||
.Select(d => $"{d.Country}:{d.City}:{d.Name}:{d.Township}:{d.Street}:{d.ZipCode}")
|
||
.ToHashSet();
|
||
|
||
var options = new JsonSerializerOptions
|
||
{
|
||
PropertyNameCaseInsensitive = true
|
||
};
|
||
|
||
// 2. JSON’u stream et
|
||
using FileStream fs = File.OpenRead(Path.Combine("Seeds", "Districts.json"));
|
||
|
||
var buffer = new List<District>(capacity: 5000);
|
||
await foreach (var item in JsonSerializer.DeserializeAsyncEnumerable<DistrictDto>(fs, options))
|
||
{
|
||
if (item == null) continue;
|
||
|
||
var key = $"{item.Country}:{item.Country}.{item.City}:{item.Name}:{item.Township}:{item.Street}:{item.ZipCode}";
|
||
var city = $"{item.Country}.{item.City}";
|
||
if (existingSet.Contains(key)) continue;
|
||
|
||
buffer.Add(new District(
|
||
Guid.NewGuid(),
|
||
item.Country,
|
||
city,
|
||
item.Name,
|
||
item.Township,
|
||
item.Street,
|
||
item.ZipCode
|
||
));
|
||
|
||
if (buffer.Count >= 5000) // 3. Batch
|
||
{
|
||
await BulkDistrictInsertAsync(buffer);
|
||
buffer.Clear();
|
||
}
|
||
}
|
||
|
||
if (buffer.Count > 0)
|
||
{
|
||
await BulkDistrictInsertAsync(buffer);
|
||
}
|
||
}
|
||
|
||
private async Task BulkDistrictInsertAsync(List<District> entities)
|
||
{
|
||
var dbCtx = await _districtRepository.GetDbContextAsync();
|
||
await dbCtx.BulkInsertAsync(entities, new BulkConfig
|
||
{
|
||
PreserveInsertOrder = true,
|
||
SetOutputIdentity = true,
|
||
BatchSize = 5000
|
||
});
|
||
}
|
||
|
||
public async Task SeedAsync(DataSeedContext context)
|
||
{
|
||
var settings = await _settings.GetListAsync();
|
||
var dataSources = await _dataSources.GetListAsync();
|
||
var languages = await _languages.GetListAsync();
|
||
var keys = await _languageKey.GetListAsync();
|
||
var texts = await _languagesText.GetListAsync();
|
||
|
||
var configuration = new ConfigurationBuilder()
|
||
.SetBasePath(Directory.GetCurrentDirectory())
|
||
.AddJsonFile(Path.Combine("Seeds", "SeederData.json"))
|
||
.AddJsonFile(Path.Combine("Seeds", $"SeederData.{Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ?? ""}.json"), true)
|
||
.Build();
|
||
var items = configuration.Get<SeederDto>();
|
||
|
||
var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
|
||
|
||
foreach (var item in items.Settings)
|
||
{
|
||
if (!settings.Any(a => a.Code == item.Code))
|
||
{
|
||
await _settings.InsertAsync(new()
|
||
{
|
||
Code = item.Code,
|
||
NameKey = item.NameKey,
|
||
DescriptionKey = item.DescriptionKey,
|
||
DefaultValue = item.DefaultValue.Replace("\r\n", Environment.NewLine),
|
||
IsVisibleToClients = item.IsVisibleToClients,
|
||
IsInherited = item.IsInherited,
|
||
IsEncrypted = item.IsEncrypted,
|
||
MainGroupKey = item.MainGroupKey,
|
||
SubGroupKey = item.SubGroupKey,
|
||
RequiredPermissionName = item.RequiredPermissionName,
|
||
DataType = item.DataType,
|
||
Providers = item.Providers,
|
||
SelectOptions = item.SelectOptions,
|
||
Order = item.Order
|
||
});
|
||
}
|
||
}
|
||
|
||
if (!dataSources.Any(a => a.Code == SeedConsts.DataSources.DefaultCode))
|
||
{
|
||
var config = BuildConfiguration();
|
||
await _dataSources.InsertAsync(new()
|
||
{
|
||
Code = SeedConsts.DataSources.DefaultCode,
|
||
DataSourceType = DefaultDatabaseProvider == DatabaseProvider.SqlServer ? DataSourceTypeEnum.Mssql : DataSourceTypeEnum.Postgresql,
|
||
ConnectionString = config.GetConnectionString(DefaultDatabaseProvider)
|
||
});
|
||
}
|
||
|
||
foreach (var item in items.Languages)
|
||
{
|
||
if (!languages.Any(a => a.CultureName == item.CultureName))
|
||
{
|
||
await _languages.InsertAsync(new()
|
||
{
|
||
CultureName = item.CultureName,
|
||
UiCultureName = item.UiCultureName,
|
||
DisplayName = item.DisplayName,
|
||
IsEnabled = item.IsEnabled,
|
||
TwoLetterISOLanguageName = new CultureInfo(item.CultureName).TwoLetterISOLanguageName,
|
||
});
|
||
}
|
||
|
||
}
|
||
|
||
foreach (var item in items.LanguageTexts)
|
||
{
|
||
try
|
||
{
|
||
if (!keys.Any(a => a.Key == item.Key))
|
||
{
|
||
await _languageKey.InsertAsync(new()
|
||
{
|
||
Key = item.Key,
|
||
ResourceName = item.ResourceName,
|
||
});
|
||
}
|
||
if (!texts.Any(a => a.CultureName == "en" && a.Key == item.Key))
|
||
{
|
||
await _languagesText.InsertAsync(new()
|
||
{
|
||
CultureName = "en",
|
||
Key = item.Key,
|
||
Value = item.En,
|
||
ResourceName = item.ResourceName,
|
||
});
|
||
}
|
||
if (!texts.Any(a => a.CultureName == "tr" && a.Key == item.Key))
|
||
{
|
||
|
||
await _languagesText.InsertAsync(new()
|
||
{
|
||
CultureName = "tr",
|
||
Key = item.Key,
|
||
Value = item.Tr,
|
||
ResourceName = item.ResourceName,
|
||
});
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw new Exception($"Hata veren Kod:' ResourceName='{item.ResourceName}', Key='{item.Key}'.");
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.GlobalSearch)
|
||
{
|
||
if (!await _globalSearch.AnyAsync(x => x.System == item.System && x.Group == item.Group && x.Term == item.Term))
|
||
{
|
||
await _globalSearch.InsertAsync(new GlobalSearch
|
||
{
|
||
System = item.System,
|
||
Group = item.Group,
|
||
Term = item.Term,
|
||
Weight = item.Weight,
|
||
Url = item.Url
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.BackgroundWorkers)
|
||
{
|
||
if (!await _backgroundWorkerRepository.AnyAsync(x => x.Name == item.Name))
|
||
{
|
||
await _backgroundWorkerRepository.InsertAsync(new BackgroundWorker
|
||
{
|
||
Name = item.Name,
|
||
Cron = item.Cron,
|
||
WorkerType = Enum.Parse<WorkerTypeEnum>(item.WorkerType),
|
||
IsActive = item.IsActive,
|
||
DataSourceCode = item.DataSourceCode
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.NotificationRules)
|
||
{
|
||
var exists = await _notificationRuleRepository.AnyAsync(x =>
|
||
x.NotificationType == item.NotificationType &&
|
||
x.RecipientType == item.RecipientType &&
|
||
x.RecipientId == item.RecipientId &&
|
||
x.Channel == item.Channel);
|
||
|
||
if (!exists)
|
||
{
|
||
await _notificationRuleRepository.InsertAsync(new NotificationRule
|
||
{
|
||
NotificationType = item.NotificationType,
|
||
RecipientType = item.RecipientType,
|
||
RecipientId = item.RecipientId,
|
||
Channel = item.Channel,
|
||
IsActive = item.IsActive,
|
||
IsFixed = item.IsFixed,
|
||
IsCustomized = item.IsCustomized
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Menus)
|
||
{
|
||
var exists = await _menuRepository.AnyAsync(x => x.Code == item.Code);
|
||
|
||
if (!exists)
|
||
{
|
||
await _menuRepository.InsertAsync(new Menu
|
||
{
|
||
ParentCode = string.IsNullOrWhiteSpace(item.ParentCode) ? null : item.ParentCode,
|
||
Code = item.Code,
|
||
DisplayName = item.DisplayName,
|
||
Order = item.Order,
|
||
Url = item.Url,
|
||
Icon = item.Icon,
|
||
RequiredPermissionName = item.RequiredPermissionName,
|
||
IsDisabled = item.IsDisabled
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.PermissionGroupDefinitionRecords)
|
||
{
|
||
var exists = await _permissionGroupRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _permissionGroupRepository.InsertAsync(new PermissionGroupDefinitionRecord
|
||
{
|
||
Name = item.Name,
|
||
DisplayName = item.DisplayName
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.PermissionDefinitionRecords)
|
||
{
|
||
var exists = await _permissionRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _permissionRepository.InsertAsync(new PermissionDefinitionRecord
|
||
{
|
||
GroupName = item.GroupName,
|
||
Name = item.Name,
|
||
ParentName = string.IsNullOrWhiteSpace(item.ParentName) ? null : item.ParentName,
|
||
DisplayName = item.DisplayName,
|
||
IsEnabled = item.IsEnabled,
|
||
MultiTenancySide = (MultiTenancySides)item.MultiTenancySide
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Sectors)
|
||
{
|
||
var exists = await _sectorRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _sectorRepository.InsertAsync(new Sector
|
||
{
|
||
Name = item.Name,
|
||
FullName = item.FullName
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.UomCategories)
|
||
{
|
||
var exists = await _uomCategoryRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _uomCategoryRepository.InsertAsync(new UomCategory(item.Id, item.Name));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Uoms)
|
||
{
|
||
var exists = await _uomRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _uomRepository.InsertAsync(new Uom
|
||
{
|
||
Name = item.Name,
|
||
Type = item.Type,
|
||
Ratio = item.Ratio,
|
||
IsActive = item.IsActive,
|
||
Rounding = item.Rounding,
|
||
UomCategoryId = item.UomCategoryId
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Currencies)
|
||
{
|
||
var exists = await _currencyRepository.AnyAsync(x => x.Code == item.Code);
|
||
|
||
if (!exists)
|
||
{
|
||
await _currencyRepository.InsertAsync(new Currency
|
||
{
|
||
Code = item.Code,
|
||
Symbol = item.Symbol,
|
||
Name = item.Name,
|
||
IsActive = item.IsActive
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.SkillTypes)
|
||
{
|
||
var exists = await _skillTypeRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _skillTypeRepository.InsertAsync
|
||
(
|
||
new SkillType(item.Id, item.Name)
|
||
);
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Skills)
|
||
{
|
||
var exists = await _skillRepository.AnyAsync(x => x.Name == item.Name && x.SkillTypeId == item.SkillTypeId);
|
||
|
||
if (!exists)
|
||
{
|
||
await _skillRepository.InsertAsync(new Skill
|
||
{
|
||
Name = item.Name,
|
||
SkillTypeId = item.SkillTypeId
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.SkillLevels)
|
||
{
|
||
var exists = await _skillLevelRepository.AnyAsync(x => x.Name == item.Name && x.SkillTypeId == item.SkillTypeId);
|
||
|
||
if (!exists)
|
||
{
|
||
await _skillLevelRepository.InsertAsync(new SkillLevel
|
||
{
|
||
Name = item.Name,
|
||
Progress = item.Progress,
|
||
IsDefault = item.IsDefault,
|
||
SkillTypeId = item.SkillTypeId,
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.ContactTags)
|
||
{
|
||
var exists = await _contactTagRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _contactTagRepository.InsertAsync(new ContactTag
|
||
{
|
||
Name = item.Name,
|
||
Category = item.Category,
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.ContactTitles)
|
||
{
|
||
var exists = await _contactTitleRepository.AnyAsync(x => x.Title == item.Title);
|
||
|
||
if (!exists)
|
||
{
|
||
await _contactTitleRepository.InsertAsync(new ContactTitle
|
||
{
|
||
Title = item.Title,
|
||
Abbreviation = item.Abbreviation,
|
||
});
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.BlogCategories)
|
||
{
|
||
var exists = await _blogCategoryRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
var newCategory = new BlogCategory(
|
||
item.Id,
|
||
item.Name,
|
||
item.Slug,
|
||
item.Description
|
||
)
|
||
{
|
||
DisplayOrder = item.DisplayOrder,
|
||
PostCount = item.PostCount
|
||
};
|
||
|
||
await _blogCategoryRepository.InsertAsync(newCategory);
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.BlogPosts)
|
||
{
|
||
var exists = await _blogPostsRepository.AnyAsync(x => x.Title == item.Title);
|
||
|
||
if (!exists)
|
||
{
|
||
await _blogPostsRepository.InsertAsync(new BlogPost(
|
||
Guid.NewGuid(),
|
||
item.Title,
|
||
item.Slug,
|
||
item.ContentTr,
|
||
item.ContentEn,
|
||
item.Summary,
|
||
item.ReadTime,
|
||
item.CoverImage,
|
||
item.CategoryId,
|
||
item.AuthorId,
|
||
true,
|
||
DateTime.UtcNow
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.ForumCategories)
|
||
{
|
||
var exists = await _forumCategoryRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
var newCategory = new ForumCategory(
|
||
Guid.NewGuid(),
|
||
item.Name,
|
||
item.Slug,
|
||
item.Description,
|
||
item.Icon,
|
||
item.DisplayOrder
|
||
);
|
||
|
||
await _forumCategoryRepository.InsertAsync(newCategory);
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.AiBots)
|
||
{
|
||
var exists = await _aiBotRepository.AnyAsync(x => x.BotName == item.BotName);
|
||
|
||
if (!exists)
|
||
{
|
||
await _aiBotRepository.InsertAsync(new AiBot(
|
||
Guid.NewGuid(),
|
||
item.BotName
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Routes)
|
||
{
|
||
var exists = await _routeRepository.AnyAsync(x => x.Key == item.Key);
|
||
|
||
if (!exists)
|
||
{
|
||
await _routeRepository.InsertAsync(new Route(
|
||
item.Key,
|
||
item.Path,
|
||
item.ComponentPath,
|
||
item.RouteType,
|
||
item.Authority ?? []
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.CustomEndpoints)
|
||
{
|
||
var exists = await _customEndpointRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _customEndpointRepository.InsertAsync(new CustomEndpoint(
|
||
item.Name,
|
||
item.Description,
|
||
item.Url,
|
||
item.Method,
|
||
item.DataSourceCode,
|
||
item.Sql,
|
||
JsonSerializer.Serialize(item.ParametersJson),
|
||
JsonSerializer.Serialize(item.PermissionsJson)
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Products)
|
||
{
|
||
var exists = await _productRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _productRepository.InsertAsync(new Product(
|
||
Guid.NewGuid(),
|
||
item.Name,
|
||
item.Description,
|
||
item.Category,
|
||
item.Order,
|
||
item.MonthlyPrice,
|
||
item.YearlyPrice,
|
||
item.IsQuantityBased,
|
||
item.ImageUrl
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.PaymentMethods)
|
||
{
|
||
var exists = await _paymentMethodRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _paymentMethodRepository.InsertAsync(new PaymentMethod(
|
||
item.Id,
|
||
item.Name,
|
||
item.Commission,
|
||
item.Logo
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.InstallmentOptions)
|
||
{
|
||
var exists = await _installmentOptionRepository.AnyAsync(x => x.Installment == item.Installment);
|
||
|
||
if (!exists)
|
||
{
|
||
await _installmentOptionRepository.InsertAsync(new InstallmentOption(
|
||
item.Installment,
|
||
item.Name,
|
||
item.Commission));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.CustomComponents)
|
||
{
|
||
var exists = await _customComponentRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _customComponentRepository.InsertAsync(new CustomComponent(
|
||
item.Name,
|
||
item.Code,
|
||
item.Props,
|
||
item.Description,
|
||
item.IsActive,
|
||
JsonSerializer.Serialize(item.Dependencies)));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.ReportCategories)
|
||
{
|
||
var exists = await _reportCategoriesRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _reportCategoriesRepository.InsertAsync(new ReportCategory(
|
||
Guid.NewGuid(),
|
||
item.Name,
|
||
item.Description,
|
||
item.Icon));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Services)
|
||
{
|
||
var exists = await _servicesRepository.AnyAsync(x => x.Title == item.Title);
|
||
|
||
if (!exists)
|
||
{
|
||
await _servicesRepository.InsertAsync(new Service(
|
||
Guid.NewGuid(),
|
||
item.Icon,
|
||
item.Title,
|
||
item.Description,
|
||
item.Type,
|
||
item.Features
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Abouts)
|
||
{
|
||
var exists = await _aboutRepository.FirstOrDefaultAsync();
|
||
if (exists == null)
|
||
{
|
||
await _aboutRepository.InsertAsync(new About(
|
||
Guid.NewGuid(),
|
||
JsonSerializer.Serialize(item.Stats),
|
||
JsonSerializer.Serialize(item.Descriptions),
|
||
JsonSerializer.Serialize(item.Sections)
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Contacts)
|
||
{
|
||
var exists = await _contactRepository.FirstOrDefaultAsync();
|
||
if (exists == null)
|
||
{
|
||
await _contactRepository.InsertAsync(new Contact(
|
||
Guid.NewGuid(),
|
||
item.Address,
|
||
item.Phone,
|
||
item.Email,
|
||
item.Location,
|
||
item.TaxNumber,
|
||
JsonSerializer.Serialize(item.Bank),
|
||
JsonSerializer.Serialize(item.WorkHour),
|
||
JsonSerializer.Serialize(item.Map)
|
||
));
|
||
}
|
||
}
|
||
|
||
foreach (var item in items.Classrooms)
|
||
{
|
||
var exists = await _classroomRepository.AnyAsync(x => x.Name == item.Name);
|
||
|
||
if (!exists)
|
||
{
|
||
await _classroomRepository.InsertAsync(new Classroom(
|
||
Guid.NewGuid(),
|
||
item.Name,
|
||
item.Description,
|
||
item.Subject,
|
||
item.TeacherId,
|
||
item.TeacherName,
|
||
item.ScheduledStartTime,
|
||
item.ScheduledEndTime,
|
||
item.Duration,
|
||
item.MaxParticipants,
|
||
item.SettingsJson
|
||
));
|
||
}
|
||
}
|
||
|
||
await SeedCountyGroupsAsync();
|
||
|
||
await SeedCountriesAsync();
|
||
|
||
await SeedCitiesAsync();
|
||
|
||
await SeedDistrictsAsync();
|
||
}
|
||
}
|