public async void Get_Returns_OkObjectResult_With_StudioDto()
{
var dto = new StudioDto
{
Id = Guid.NewGuid(),
Name = "Studio",
FriendlyUrl = "FriendlyUrl",
PostalCode = "11111"
};
_studioService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(dto));
var result = await _studiosController.Get(dto.Id);
Assert.IsType <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.IsType <StudioDto>(okResult.Value);
var model = okResult.Value as StudioDto;
Assert.Equal(dto.Id, model.Id);
Assert.Equal(dto.Name, model.Name);
Assert.Equal(dto.FriendlyUrl, model.FriendlyUrl);
Assert.Equal(dto.PostalCode, model.PostalCode);
}
public async Task <IActionResult> PutStudio(int id, StudioDto studioDto)
{
if (id != studioDto.Id)
{
return(BadRequest());
}
try
{
var studio = _mapper.Map <Studio>(studioDto);
await _repository.Update(studio);
}
catch (DbUpdateConcurrencyException)
{
if (!StudioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Studio ToStudio(StudioDto studioDto)
{
return(new Studio()
{
Id = studioDto.Id,
Name = studioDto.Name
});
}
public async Task <IActionResult> Put([FromBody] StudioDto model)
{
ArgumentNotNullValidator.Validate(model, nameof(model));
ValidateUserIsOwner(model.OwnerUserId);
var studio = await _studioService.UpdateAsync(model);
return(Ok(studio));
}
public async Task <ActionResult <StudioDto> > PostStudio(StudioDto studioDto)
{
var studio = _mapper.Map <Studio>(studioDto);
studio = await _repository.Add(studio);
var result = _mapper.Map <StudioDto>(studio);
return(CreatedAtAction("GetStudio", new { id = result.Id }, result));
}
public async Task <IActionResult> Post([FromBody] StudioDto model)
{
ArgumentNotNullValidator.Validate(model, nameof(model));
model.OwnerUserId = UserId.Value;
var studio = await _studioService.CreateAsync(model);
var studioUri = ApiHelper.GetResourceUri("studios", studio.Id);
return(Created(studioUri, studio));
}
public async Task AddStudio(StudioDto dto)
{
var studioEntity = new Studio
{
Id = dto.Id,
CreationDate = DateTime.UtcNow,
ModifiedDate = DateTime.UtcNow,
Name = dto.Name
};
await _studioRepository.AddAsync(studioEntity);
}
public static StudioDto MapStudio(Studio studio)
{
var studioDto = new StudioDto()
{
Id = studio.Id,
Name = studio.Name,
LastUpdatedDate = studio.LastUpdatedDate,
CreatedDate = studio.CreatedDate
};
return(studioDto);
}
/// <summary>
/// Attaches the studios.
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
private async Task AttachStudios(BaseItemDto dto, BaseItem item)
{
var studios = item.Studios.ToList();
dto.Studios = new StudioDto[studios.Count];
var entities = await Task.WhenAll(studios.Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
Task.Run(async() =>
{
try
{
return(await _libraryManager.GetStudio(c).ConfigureAwait(false));
}
catch (IOException ex)
{
_logger.ErrorException("Error getting studio {0}", ex, c);
return(null);
}
})
)).ConfigureAwait(false);
var dictionary = entities
.Where(i => i != null)
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < studios.Count; i++)
{
var studio = studios[i];
var studioDto = new StudioDto
{
Name = studio
};
Studio entity;
if (dictionary.TryGetValue(studio, out entity))
{
var primaryImagePath = entity.PrimaryImagePath;
if (!string.IsNullOrEmpty(primaryImagePath))
{
studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary, primaryImagePath);
}
}
dto.Studios[i] = studioDto;
}
}
public static void AddToCache(StudioDto dto)
{
lock (StudioCache)
{
if (!StudioCache.ContainsKey(dto.Name))
{
StudioCache[dto.Name] = new Studio
{
Name = dto.Name,
PrimaryImagePath = dto.HasPrimaryImage ? Kernel.ApiClient.GetImageUrl("Studios/" + dto.Name + "/Images/Primary", new ImageOptions {
Tag = dto.PrimaryImageTag
}, new QueryStringDictionary()) : null
};
}
}
}
public async void CreateRoom_Returns_CreatedResult_With_RoomDto_And_Location()
{
var userId = Guid.NewGuid();
var studioId = Guid.NewGuid();
var studio = new StudioDto
{
OwnerUserId = userId
};
var model = new RoomDto
{
Id = Guid.NewGuid(),
Name = "Studio"
};
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(userId.ToString());
_studioService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(studio));
_studioService
.Setup(s => s.CreateRoomAsync(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <RoomDto>()))
.Returns(Task.FromResult(model));
var result = await _studiosController.CreateRoom(studioId, model);
Assert.IsType <CreatedResult>(result);
var created = result as CreatedResult;
Assert.IsType <RoomDto>(created.Value);
var room = created.Value as RoomDto;
Assert.Equal(model.Id, room.Id);
Assert.Equal(model.Name, room.Name);
var expectedLocation = ApiHelper.GetResourceUri("studios", studioId, "rooms", model.Id);
Assert.Equal(expectedLocation, created.Location);
}
public async void Put_Returns_OkObjectResult_With_Updated_Model()
{
var model = new StudioDto
{
Id = Guid.NewGuid(),
Name = "Studio",
FriendlyUrl = "FriendlyUrl",
PostalCode = "11111",
OwnerUserId = Guid.NewGuid()
};
var updatedModel = new StudioDto
{
Id = model.Id,
Name = "Studio_Updated",
FriendlyUrl = "FriendlyUrl_Updated",
PostalCode = "22222",
OwnerUserId = model.OwnerUserId
};
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(model.OwnerUserId.ToString());
_studioService
.Setup(s => s.UpdateAsync(It.IsAny <StudioDto>()))
.Returns(Task.FromResult(updatedModel));
var result = await _studiosController.Put(model);
Assert.IsType <OkObjectResult>(result);
var ok = result as OkObjectResult;
Assert.IsType <StudioDto>(ok.Value);
var studio = ok.Value as StudioDto;
Assert.Equal(updatedModel.Id, studio.Id);
Assert.Equal(updatedModel.Name, studio.Name);
Assert.Equal(updatedModel.FriendlyUrl, studio.FriendlyUrl);
Assert.Equal(updatedModel.PostalCode, studio.PostalCode);
Assert.Equal(updatedModel.OwnerUserId, studio.OwnerUserId);
}
/// <summary>
/// Attaches the studios.
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
private void AttachStudios(BaseItemDto dto, BaseItem item)
{
var studios = item.Studios.ToList();
dto.Studios = new StudioDto[studios.Count];
var dictionary = studios.Distinct(StringComparer.OrdinalIgnoreCase).Select(name =>
{
try
{
return(_libraryManager.GetStudio(name));
}
catch (IOException ex)
{
_logger.ErrorException("Error getting studio {0}", ex, name);
return(null);
}
})
.Where(i => i != null)
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < studios.Count; i++)
{
var studio = studios[i];
var studioDto = new StudioDto
{
Name = studio
};
Studio entity;
if (dictionary.TryGetValue(studio, out entity))
{
studioDto.Id = entity.Id.ToString("N");
studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary);
}
dto.Studios[i] = studioDto;
}
}
public async void Post_Returns_CreatedResult_With_StudioDto_And_Location()
{
var model = new StudioDto
{
Id = Guid.NewGuid(),
Name = "Studio",
FriendlyUrl = "FriendlyUrl",
PostalCode = "11111",
OwnerUserId = Guid.NewGuid()
};
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(model.OwnerUserId.ToString());
_studioService
.Setup(s => s.CreateAsync(It.IsAny <StudioDto>()))
.Returns(Task.FromResult(model));
var result = await _studiosController.Post(model);
Assert.IsType <CreatedResult>(result);
var created = result as CreatedResult;
Assert.IsType <StudioDto>(created.Value);
var studio = created.Value as StudioDto;
Assert.Equal(model.Id, studio.Id);
Assert.Equal(model.Name, studio.Name);
Assert.Equal(model.FriendlyUrl, studio.FriendlyUrl);
Assert.Equal(model.PostalCode, studio.PostalCode);
Assert.Equal(model.OwnerUserId, studio.OwnerUserId);
var expectedLocation = ApiHelper.GetResourceUri("studios", model.Id);
Assert.Equal(expectedLocation, created.Location);
}
public async void CreateAsync_Returns_New_StudioDto()
{
var name = "StudioName";
var friendlyUrl = "FriendlyUrl";
var postalCode = "12345";
var ownerUserId = Guid.NewGuid();
var model = Studio.Create(name, friendlyUrl, postalCode, ownerUserId, _studioValidator.Object);
_studioRepository
.Setup(r => r.CreateAsync(It.IsAny <Studio>()))
.Returns(Task.FromResult(model));
var dto = new StudioDto {
Name = name, FriendlyUrl = friendlyUrl, PostalCode = postalCode, OwnerUserId = ownerUserId
};
var result = await _studioService.CreateAsync(dto);
Assert.NotNull(result);
Assert.Equal(name, result.Name);
Assert.Equal(friendlyUrl, result.FriendlyUrl);
Assert.Equal(ownerUserId, result.OwnerUserId);
Assert.Equal(postalCode, result.PostalCode);
}
public async void CreateSession_Throws_UnauthorizedAccessException(string userId)
{
var studio = new StudioDto
{
OwnerUserId = Guid.NewGuid()
};
var room = new RoomDto
{
StudioId = studio.Id
};
var session = new SessionDto
{
Id = Guid.NewGuid()
};
_studioService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(studio));
_roomService
.Setup(r => r.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
var isAuthenticated = userId != null;
_identity.Setup(i => i.IsAuthenticated).Returns(isAuthenticated);
_identity.Setup(i => i.Name).Returns(userId);
var ex = await Assert.ThrowsAsync <UnauthorizedAccessException>(
() =>
_roomsController.CreateSession(room.Id, session));
Assert.NotNull(ex);
}
public async Task <IActionResult> Add([FromBody] StudioDto dto)
{
await _studioService.AddStudio(dto);
return(Ok(true));
}
public async void StartSession_And_EndSession_Return_SessionDto_With_ActualStartTime_ActualEndTime(bool startSession)
{
var userId = Guid.NewGuid();
var roomId = Guid.NewGuid();
var start = DateTime.Now;
var end = start.AddHours(2);
var actualStart = DateTime.Now;
var actualEnd = actualStart.AddHours(2);
var studio = new StudioDto
{
Id = Guid.NewGuid(),
OwnerUserId = userId
};
var room = new RoomDto
{
Id = roomId,
StudioId = studio.Id
};
var dto = new SessionDto
{
Id = Guid.NewGuid(),
RoomId = roomId,
Schedule = new DateRangeDto
{
Start = start,
End = end
},
ActualStartTime = startSession ? actualStart : (DateTime?)null,
ActualEndTime = !startSession ? actualEnd : (DateTime?)null
};
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(userId.ToString());
_studioService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(studio));
_roomService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
_roomService
.Setup(s => s.StartSessionAsync(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(Task.FromResult(dto));
_roomService
.Setup(s => s.EndSessionAsync(It.IsAny <Guid>(), It.IsAny <Guid>()))
.Returns(Task.FromResult(dto));
var result =
startSession
? await _roomsController.StartSession(roomId, dto.Id)
: await _roomsController.EndSession(roomId, dto.Id);
Assert.IsType <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.IsType <SessionDto>(okResult.Value);
var session = okResult.Value as SessionDto;
if (startSession)
{
Assert.NotNull(session.ActualStartTime);
Assert.Equal(dto.ActualStartTime, session.ActualStartTime);
}
else
{
Assert.NotNull(session.ActualEndTime);
Assert.Equal(dto.ActualEndTime, session.ActualEndTime);
}
}
public async void CreateSession_Returns_CreatedResult_With_SessionDto_And_Location()
{
var userId = Guid.NewGuid();
var roomId = Guid.NewGuid();
var start = new DateTime(2018, 1, 1, 10, 0, 0, DateTimeKind.Unspecified);
var end = start.AddHours(2);
var studio = new StudioDto
{
Id = Guid.NewGuid(),
OwnerUserId = userId
};
var room = new RoomDto
{
Id = roomId,
StudioId = studio.Id
};
var dto = new SessionDto
{
RoomId = roomId,
Schedule = new DateRangeDto
{
Start = start,
End = end
}
};
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(userId.ToString());
_identity.Setup(i => i.Claims).Returns(new List <Claim>
{
new Claim(ClaimTypes.Name, userId.ToString()),
new Claim(ApiClaimTypes.TimeZoneId, "1"),
new Claim(ApiClaimTypes.TimeZoneName, "Central Standard Time"),
new Claim(ApiClaimTypes.TimeZoneUtcOffset, "-6")
});
_studioService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(studio));
_roomService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
_roomService
.Setup(s => s.CreateSessionAsync(It.IsAny <Guid>(), It.IsAny <SessionDto>()))
.Returns(Task.FromResult(dto));
var result = await _roomsController.CreateSession(room.Id, dto);
Assert.IsType <CreatedResult>(result);
var created = result as CreatedResult;
Assert.IsType <SessionDto>(created.Value);
var model = created.Value as SessionDto;
Assert.Equal(dto.RoomId, model.RoomId);
Assert.NotNull(model.Schedule);
Assert.Equal(dto.Schedule.Start, model.Schedule.Start);
Assert.Equal(dto.Schedule.End, model.Schedule.End);
var createdLocation = created.Location;
var expectedLocation = ApiHelper.GetResourceUri("rooms", roomId, "sessions", model.Id);
Assert.Equal(expectedLocation, createdLocation);
}
