public override void Import(string path)
{
LoadData(path);
PhotosOfAccommodations = new HashSet <PhotoOfAccommodation>(Photos.Select(p => new PhotoOfAccommodation
{
AccommodationId = p.AccommodationId,
PathToPhotoId = p.PathId,
FileName = p.FileName,
FileExtensionId = p.ExtensionId,
CreatorId = CreatorId,
IsDefault = p.IsDefault
}));
var count = PhotosOfAccommodations.Count;
WriteLog($"Builded {count} {typeof(PhotoOfAccommodation)}.");
if (count <= 0)
{
return;
}
LogSave <PhotoOfAccommodation>();
FactoryOfRepositories.PhotosOfAccommodations().BulkSave(PhotosOfAccommodations, p => p.CaptionId, p => p.IsDefault);
LogSaved <PhotoOfAccommodation>();
}
public override void Import(string path)
{
Parser = _parserFactory.Create <Country>(Provider.GetFirstLine(path));
LoadData(path);
var eanCountries = EanCountries.ToArray();
EanCountries = null;
var regionsRepository = FactoryOfRepositories.Regions();
var regionsEanIdsToIds = regionsRepository.EanIdsToIds;
regionsEanIdsToIds = ImportRegions(eanCountries, regionsRepository, regionsEanIdsToIds);
ImportLocalizedRegions(eanCountries, FactoryOfRepositories.Localized <LocalizedRegion>(), regionsEanIdsToIds);
var typeOfRegionCountryId = FactoryOfRepositories.BaseNames <TypeOfRegion>().GetId("Country");
ImportRegionsToTypes(eanCountries, FactoryOfRepositories.RegionsToTypes(), regionsEanIdsToIds, typeOfRegionCountryId);
ImportRegionsToRegions(eanCountries, FactoryOfRepositories.ManyToMany <RegionToRegion>(), regionsEanIdsToIds);
var countriesRepository = FactoryOfRepositories.AdditionalRegionsInfo <Data.Entity.Country>();
ImportCountries(eanCountries, countriesRepository, regionsEanIdsToIds);
ImportProbablyMissingCoutries(ProbablyMissingCoutries, countriesRepository, typeOfRegionCountryId, regionsRepository);
}
public override void Import(string path)
{
var languageId = CultureInfo(EanLanguageCode(System.IO.Path.GetFileName(path))).LCID;
LoadData(path);
ImportLocalizedAccommodations(EanDataTransferObjects, FactoryOfRepositories.OfLocalized <LocalizedAccommodation>(),
FactoryOfRepositories.MappedProperties <Accommodation>().EanIdsToIds, languageId, CreatorId);
EanDataTransferObjects = null;
}
public override void Import(string path)
{
LoadData(path);
var eanIdsToIds = ImportRegions(EanDataTransferObjects, FactoryOfRepositories.Regions(), CreatorId);
ImportLocalizedRegions(EanDataTransferObjects, FactoryOfRepositories.Localized <LocalizedRegion>(), eanIdsToIds,
DefaultLanguageId, CreatorId);
EanDataTransferObjects = null;
}
public override void Import(string path)
{
LoadData(path);
var typesOfAccommodationsEanIdsToIds = ImportTypesOfAccommodations(EanIdsToNames.Keys,
FactoryOfRepositories.MappedProperties <TypeOfAccommodation>(), CreatorId);
ImportLocalizedTypesOfAccommodations(EanIdsToNames,
FactoryOfRepositories.OfLocalized <LocalizedTypeOfAccommodation>(), typesOfAccommodationsEanIdsToIds, DefaultLanguageId,
CreatorId);
EanIdsToNames = null;
}
public override void Import(string path)
{
LoadData(path);
var eanIdsToIds = ImportRegions(EanDataTransferObjects, FactoryOfRepositories.Regions(), CreatorId);
ImportLocalizedRegions(EanDataTransferObjects, FactoryOfRepositories.Localized <LocalizedRegion>(), eanIdsToIds,
DefaultLanguageId, CreatorId);
ImportRegionsToTypes(EanDataTransferObjects, FactoryOfRepositories.RegionsToTypes(), eanIdsToIds,
FactoryOfRepositories.BaseNames <TypeOfRegion>().GetId("Train Station"),
FactoryOfRepositories.BaseNames <SubClass>().GetId("train"), CreatorId);
EanDataTransferObjects = null;
}
public override void Import(string path)
{
LoadData(path);
if (Chains.Count <= 0)
{
return;
}
LogSave <Chain>();
FactoryOfRepositories.MappedProperties <Chain>().BulkSave(Chains);
LogSaved <Chain>();
Chains = null;
}
public override void Import(string path)
{
LogBuild <Region>();
LoadData(path);
var eanIdsToIds = ImportRegions(Regions.ToArray(), FactoryOfRepositories.Regions(), 90000, p => p.CenterCoordinates);
Regions = null;
ImportLocalizedRegions(AdeptsToLocalizedRegions, FactoryOfRepositories.OfLocalized <LocalizedRegion>(), eanIdsToIds, DefaultLanguageId, CreatorId);
var regionsEanIds = AdeptsToLocalizedRegions.Keys;
AdeptsToLocalizedRegions = null;
ImportRegionsToTypes(regionsEanIds, FactoryOfRepositories.RegionsToTypes(), eanIdsToIds, TypeOfRegionId,
SubClassId, CreatorId);
}
public override void Import(string path)
{
LoadData(path);
LogBuild <SubClass>();
var subClasses = SubClassesNames.Select(s => new SubClass {
Name = s, CreatorId = CreatorId
}).ToArray();
SubClassesNames = null;
var count = subClasses.Length;
LogAssembled(count);
if (count <= 0)
{
return;
}
LogSave <SubClass>();
FactoryOfRepositories.BaseNames <SubClass>().BulkSave(subClasses);
LogSaved <SubClass>();
}
public override void Import(string path)
{
LoadData(path);
var airportsCoordinates = EanDataTransferObjects.ToArray();
EanDataTransferObjects = null;
var regionsEanIdsToIds =
ImportRegions(airportsCoordinates, FactoryOfRepositories.Regions(), CreatorId);
ImportLocalizedRegions(airportsCoordinates, FactoryOfRepositories.Localized <LocalizedRegion>(), regionsEanIdsToIds, DefaultLanguageId, CreatorId);
ImportAirports(airportsCoordinates, FactoryOfRepositories.AdditionalRegionsInfo <Airport>(), regionsEanIdsToIds, CreatorId);
ImportRegionsToTypes(airportsCoordinates, FactoryOfRepositories.RegionsToTypes(), regionsEanIdsToIds,
FactoryOfRepositories.BaseNames <TypeOfRegion>().GetId("Airport"),
FactoryOfRepositories.BaseNames <SubClass>().GetId("airport"));
ImpotRegionsToRegions(airportsCoordinates, FactoryOfRepositories.ManyToMany <RegionToRegion>(),
regionsEanIdsToIds, FactoryOfRepositories.AdditionalRegionsInfo <Country>().CodesToIds,
CreatorId);
}
public override void Import(string path)
{
Parser = _parserFactory.Create <ParentRegion>(Provider.GetFirstLine(path));
LoadData(path);
var parentRegions = ParentRegions.ToArray();
const int batchSize = 300000;
var eanRegionIdsToIds = ImportRegions(parentRegions, FactoryOfRepositories.Regions(), batchSize, CreatorId,
out var subClassNames);
var subClasses = ImportSubClasses(FactoryOfRepositories.GeographyNamesRepository <SubClass>(), subClassNames, CreatorId);
ImportRegionsToTypes(parentRegions, FactoryOfRepositories.GeographyManyToMany <RegionToType>(), batchSize,
eanRegionIdsToIds, FactoryOfRepositories.GeographyNamesRepository <TypeOfRegion>().NamesToIds, subClasses, CreatorId);
ImportLocalized(parentRegions, FactoryOfRepositories.OfLocalized <LocalizedRegion>(), batchSize, eanRegionIdsToIds, DefaultLanguageId, CreatorId);
ImportRegionsToRegions(parentRegions, FactoryOfRepositories.GeographyManyToMany <RegionToRegion>(), batchSize, eanRegionIdsToIds, CreatorId);
ParentRegions = null;
}
public RegionsTypesOfCitiesImporter(IProvider provider, IFactoryOfRepositories factoryOfRepositories, SharedProperties sharedProperties, ILoggingImports logger)
: base(provider, factoryOfRepositories, sharedProperties, logger)
{
TypeOfRegionId = FactoryOfRepositories.BaseNames <TypeOfRegion>().GetId("City");
SubClassId = FactoryOfRepositories.BaseNames <SubClass>().GetId("city");
}
public NeighborhoodsImporter(IProvider provider, IFactoryOfRepositories factoryOfRepositories, SharedProperties sharedProperties, ILoggingImports logger)
: base(provider, factoryOfRepositories, sharedProperties, logger)
{
TypeOfRegionId = FactoryOfRepositories.BaseNames <TypeOfRegion>().GetId("Neighborhood");
SubClassId = FactoryOfRepositories.BaseNames <SubClass>().GetId("neighbor");
}
