public async Task <HallDTO> ReadHallAsync(string id)
{
if (!App.Settings.UseCache)
{
return(null);
}
string language = Thread.CurrentThread.CurrentUICulture.Name.Substring(0, 2);
var keys = await BlobCache.LocalMachine.GetAllKeys();
if (keys.Contains($"{language}{id}"))
{
_logger.Info($"Read hall {language}-{id} from cache");
// Read hall
HallDTO hall = await BlobCache.LocalMachine.GetObject <HallDTO>($"{language}{id}");
// Read photo
var photos = await BlobCache.LocalMachine.GetObject <List <byte[]> >($"photo{id}");
for (int i = 0; i < hall.Stands.Count; i++)
{
hall.Stands[i].Photo.Photo = photos[i];
}
return(hall);
}
return(null);
}
public async Task <HallDTO> LoadHallAsync(string id, HallDTO hallCached, CancellationToken cancellationToken)
{
if (CheckConnection())
{
try
{
string content = await LoadAsync(new Uri($"{App.UriBase}/api/Halls/{id}?hash={hallCached.GetHashCode()}"), cancellationToken);
if (string.IsNullOrEmpty(content))
{
return(hallCached);
}
HallDTO hall = JsonConvert.DeserializeObject <HallDTO>(content);
await DependencyService.Get <CachingService>().WriteHallAsync(hall);
return(hall);
}
catch (Exception ex)
{
if (ex is HttpRequestException || ex is WebException)
{
return(hallCached);
}
else if (ex is OperationCanceledException)
{
throw ex;
}
}
}
return(hallCached);
}
public async Task WriteHallAsync(HallDTO hall)
{
if (!App.Settings.UseCache)
{
return;
}
string language = Thread.CurrentThread.CurrentUICulture.Name.Substring(0, 2);
_logger.Info($"Write hall {language}-{hall.Id} to cache");
// Copy bytes
var photosBytes = new List <byte[]>();
foreach (var stand in hall.Stands)
{
photosBytes.Add(stand.Photo.Photo);
stand.Photo.Photo = null;
}
// Write photo
await BlobCache.LocalMachine.InsertObject($"photo{hall.Id}", photosBytes);
// Write text
await BlobCache.LocalMachine.InsertObject($"{language}{hall.Id}", hall);
for (int i = 0; i < photosBytes.Count; i++)
{
hall.Stands[i].Photo.Photo = photosBytes[i];
}
}
public async void GetAsync_RecordDoesNotExist_ShouldReturnNull()
{
const string id = "111111112111111111111113";
// Arrange
HallDTO expected = null;
// Act
var actual = await _service.GetAsync(httpRequest, id);
// Assert
Assert.Equal(expected, actual);
}
public ViewResult Hall(int playId)
{
HallDTO hallDTO = theatreService.GetHall(playId);
var mapperHall = new MapperConfiguration(cfg => cfg.CreateMap <HallDTO, HallViewModel>()).CreateMapper();
HallViewModel hallVM = mapperHall.Map <HallDTO, HallViewModel>(hallDTO);
IEnumerable <PlaceDTO> placeDTOs = orderService.GetPlaces(hallDTO.HallId);
var mapperPlace = new MapperConfiguration(cfg => cfg.CreateMap <PlaceDTO, PlaceViewModel>()).CreateMapper();
List <PlaceViewModel> placesVM = mapperPlace.Map <IEnumerable <PlaceDTO>, List <PlaceViewModel> >(placeDTOs);
placesVM.Sort(new PlaceComparator());
return(View((hallVM, placesVM as IEnumerable <PlaceViewModel>)));
}
public async Task <HallDTO> LoadHallAsync(string id, CancellationToken cancellationToken)
{
if (CheckConnection())
{
string content = await LoadAsync(new Uri($"{App.UriBase}/api/Halls/{id}"), cancellationToken);
HallDTO hall = JsonConvert.DeserializeObject <HallDTO>(content);
await DependencyService.Get <CachingService>().WriteHallAsync(hall);
return(hall);
}
throw new Error()
{
ErrorCode = Errors.Failed_Connection, Info = AppResources.ErrorMessage_LoadingFaild
};
}
public IHttpActionResult CreateHall(HallModel hallModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
HallDTO hall = _mapper.Map <HallDTO>(hallModel);
_hallService.CreateHall(hall);
return(Ok("Hall was created"));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <HallDTO> GetAsync(HttpRequest request, string id)
{
// Get language from header
StringValues language = LanguageConstants.LanguageDefault;
request?.Headers?.TryGetValue("Accept-Language", out language);
var hall = await _hallsRepository.GetAsync(id);
MapperConfiguration mapperConfiguration = null;
HallDTO hallDTO = null;
if (hall != null)
{
// Create mapping depending on language
switch (language)
{
case LanguageConstants.LanguageRu:
mapperConfiguration = HallsMappingConfigurations.GetRuConfiguration;
break;
case LanguageConstants.LanguageEn:
mapperConfiguration = HallsMappingConfigurations.GetEnConfiguration;
break;
case LanguageConstants.LanguageBy:
mapperConfiguration = HallsMappingConfigurations.GetByConfiguration;
break;
default:
mapperConfiguration = HallsMappingConfigurations.GetEnConfiguration;
break;
}
var mapper = new Mapper(mapperConfiguration);
hallDTO = mapper.Map <HallDTO>(hall);
var stands = await _standsService.GetAllAsync(request, id);
hallDTO.Stands = stands;
}
return(hallDTO);
}
public void WriteHallAsync(HallDTO hall, Dictionary <string, object> cache, Dictionary <string, object> cachePhotos, string language)
{
// Copy bytes
var photosBytes = new List <byte[]>();
foreach (var stand in hall.Stands)
{
photosBytes.Add(stand.Photo.Photo);
stand.Photo.Photo = null;
}
if (!_isPhotosSaved)
{
// Write photo
cachePhotos.Add($"photo{hall.Id}", photosBytes);
}
// Write text
cache.Add($"{language}{hall.Id}", hall);
}
