/// <summary>
/// Get LocalityInfo of locality
/// </summary>
/// <param name="localityHtId">Id of locality like Locality_12345</param>
/// <param name="languageCode"></param>
/// <returns></returns>
public async Task <Result <LocalityInfo> > GetLocalityInfo(string localityHtId, string languageCode)
{
var(_, isFailure, (type, id), error) = HtId.Parse(localityHtId);
if (isFailure)
{
return(Result.Failure <LocalityInfo>(error));
}
if (type != MapperLocationTypes.Locality)
{
return(Result.Failure <LocalityInfo>($"{localityHtId} is not Locality"));
}
var locality = await _context.Localities
.Include(x => x.Country)
.Where(l => l.Id == id || l.LocalitySynonyms.Any(s => s.ExLocalityId == id))
.Where(l => l.IsActive)
.SingleOrDefaultAsync();
if (locality == default)
{
return(Result.Failure <LocalityInfo>($"Cannot find locality for {localityHtId}"));
}
var localityInfo = new LocalityInfo
{
CountryIsoCode = locality.Country.Code,
CountryName = locality.Country.Names.GetValueOrDefault(languageCode),
CountryHtId = HtId.Create(MapperLocationTypes.Country, locality.CountryId),
LocalityName = locality.Names.GetValueOrDefault(languageCode),
LocalityHtId = localityHtId
};
return(localityInfo);
}
public async Task <Result <List <string> > > GetDeactivatedLocalities(IEnumerable <string> htIds)
{
var(_, isFailure, parsedIds, error) = HtId.Parse(MapperLocationTypes.Locality, htIds);
if (isFailure)
{
return(Result.Failure <List <string> >(error));
}
return(await _context.Localities
.Where(c => !c.IsActive)
.Where(c => parsedIds.Contains(c.Id))
.Select(c => HtId.Create(MapperLocationTypes.Locality, c.Id))
.ToListAsync());
}
private Result <int> GetId(string htId, MapperLocationTypes validType)
{
var(_, isFailure, (idType, id), error) = HtId.Parse(htId);
if (isFailure)
{
return(Result.Failure <int>(error));
}
if (idType != validType)
{
return(Result.Failure <int>($"HtId has the wrong type '{idType}'. The valid type is '{validType}'"));
}
return(id);
}
private Result <int> GetAccommodationId(string htId)
{
var(_, isFailure, (type, id), error) = HtId.Parse(htId);
if (isFailure)
{
return(Result.Failure <int>(error));
}
if (type != MapperLocationTypes.Accommodation)
{
return(Result.Failure <int>($"{type} is not supported"));
}
return(id);
}
public static Result <int> RetrieveId(string htAccommodationId)
{
var(_, isFailure, (type, id), error) = HtId.Parse(htAccommodationId);
if (isFailure)
{
return(Result.Failure <int>(error));
}
if (type != MapperLocationTypes.Accommodation)
{
return(Result.Failure <int>(
$"htAccommodationId '{htAccommodationId}' has an invalid type '{type.ToString()}'. The type must be equal '{MapperLocationTypes.Accommodation.ToString()}'"));
}
return(id);
}
public async Task <Result <List <LocalityAndSynonymMatch> > > GetLocalitiesAndSynonymsMatches(List <string> htIds)
{
var(_, isFailure, parsedIds, error) = HtId.Parse(MapperLocationTypes.Locality, htIds);
if (isFailure)
{
return(Result.Failure <List <LocalityAndSynonymMatch> >(error));
}
return(await _context.LocalitySynonyms
.Where(l => l.ExLocalityId != null)
.Where(l => parsedIds.Contains(l.ExLocalityId !.Value))
.Select(l => new LocalityAndSynonymMatch(
HtId.Create(MapperLocationTypes.Locality, l.ExLocalityId !.Value),
HtId.Create(MapperLocationTypes.Locality, l.LocalityId)
))
.ToListAsync());
}
public async Task <Result <Dictionary <string, string> > > GetAccommodationSynonymsHtIds(List <string> htIds)
{
var(_, isFailure, parsedIds, error) = HtId.Parse(MapperLocationTypes.Accommodation, htIds);
if (isFailure)
{
return(Result.Failure <Dictionary <string, string> >(error));
}
var changedHtIds = new Dictionary <string, string>();
var activeAccommodationIds = await _context.Accommodations
.Where(a => parsedIds.Contains(a.Id) && a.IsActive)
.Select(a => a.Id)
.ToListAsync();
var notFoundIds = parsedIds.Except(activeAccommodationIds);
foreach (var id in notFoundIds)
{
var changedId = await _context.HtAccommodationMappings
.Where(h => h.IsActive)
.Where(h => EF.Functions.JsonContains(h.MappedHtIds, @$ "[{id}]"))
.Select(h => h.HtId)
.SingleOrDefaultAsync();
if (changedId == default)
{
return(Result.Failure <Dictionary <string, string> >($"AccommodationId {id} is not active and not mapped to a new id"));
}
var htId = HtId.Create(MapperLocationTypes.Accommodation, id);
changedHtIds[htId] = HtId.Create(MapperLocationTypes.Accommodation, changedId);
}
return(changedHtIds);
}
public Task <Result <List <LocalitySynonymInfo> > > GetLocalitySynonyms(string localityHtId, CancellationToken cancellationToken)
=> HtId.Parse(localityHtId)
.Map(l => _dbContext.LocalitySynonyms.Include(ls => ls.Locality)
.Where(ls => ls.LocalityId == l.Id && ls.Locality.IsActive)
.Select(ls => new LocalitySynonymInfo(ls.Id, ls.Names, ls.LocalityId, ls.ExLocalityId, ls.SynonymType))
.ToListAsync(cancellationToken));