private static void LinksAreValid(Common.Api.Request.MediaHeader requestedHeader, out IList <Common.Api.Response.MediaLink> invalidLinks)
{
invalidLinks = new List <Common.Api.Response.MediaLink>();
if (requestedHeader != null)
{
foreach (var part in requestedHeader.Parts)
{
if (part != null)
{
foreach (var link in part.Version.Links)
{
if (link != null)
{
if (!Uri.TryCreate(link.Link, UriKind.Absolute, out _))
{
invalidLinks.Add(new Common.Api.Response.MediaLink
{
Link = link.Link,
LinkOrderId = link.LinkOrderId,
MediaLinkId = link.MediaLinkId != null ? (int)link.MediaLinkId : 0
});
}
}
}
}
}
}
}
private async Task <Dal.Model.MediaHeader> AddOrUpdateHeaderAsync(Common.Api.Request.MediaHeader requestedHeader, Dal.Model.User loggedUser)
{
Dal.Model.MediaHeader header = requestedHeader.MediaHeaderId == null ? new Dal.Model.MediaHeader() :
await context.MediaHeaders.SingleOrDefaultAsync(h => h.MediaHeaderId == (int)requestedHeader.MediaHeaderId);
// Change all values except PK (MediaHeaderId)
header.Name = requestedHeader.Name;
header.Year = requestedHeader.Year;
header.Description = requestedHeader.Description;
header.ReferenceLink = !string.IsNullOrWhiteSpace(requestedHeader.ReferenceLink) ? new Uri(requestedHeader.ReferenceLink) : null;
header.UserId = loggedUser.UserId;
if (requestedHeader.MediaHeaderId == null)
{
await context.MediaHeaders.AddAsync(header);
}
await context.SaveChangesAsync(); // Save to get MediaId.
requestedHeader.MediaHeaderId = header.MediaHeaderId; // Populate id in request structure, so it can be used later if needed.
// Header tags
await AddHeaderTagsAsync(requestedHeader);
// Parts
await AddPartsAsync(requestedHeader, header, loggedUser);
return(header);
}
public async Task <ActionResult <Common.Api.Response.MediaHeader> > Add(Common.Api.Request.MediaHeader requestedHeader)
{
// Always check at beginning!
var loggedUser = await GetLoggedUserAsync();
if (loggedUser != null)
{
try
{
// Validate links before saving!!!
LinksAreValid(requestedHeader, out var invalidLinks);
if (invalidLinks == null || invalidLinks.Count == 0)
{
var addedMediaHeader = await AddOrUpdateHeaderAsync(requestedHeader, loggedUser);
return(Ok(await BuildResponseHeaderAsync(addedMediaHeader.MediaHeaderId)));
}
else
{
return(BadRequest($"You sent invalid links: \n{invalidLinks.Select(l => l.Link).Aggregate((l1, l2) => l1 + "\n" + l2)}"));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
else
{
return(GetUnauthorizedLoginResponse());
}
}
public async Task Update_Single_Media()
{
// For the sake of sanity I'll use request object and convert it to JSON before calling API.
// Always set token first.
Config.Client.SetToken(this.token);
// Make some changes so we can correct it later with update command.
var wrongRequest = ExampleRequest_BreakingBad();
wrongRequest.Name += " ~some wrong text~";
wrongRequest.Parts.ToArray()[0].Name += " ~some wrong text~";
// Add wrong data.
HttpResponseMessage response = await Config.Client.PostAsync(Common.ApiRoutes.Media.Add,
new StringContent(
JsonSerializer.Serialize(wrongRequest),
Encoding.UTF8, Config.HttpMediaTypeJson));
var responseMessage = await response.Content.ReadAsStringAsync();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, responseMessage);
Common.Api.Response.MediaHeader responseHeader = JsonSerializer.Deserialize <Common.Api.Response.MediaHeader>(responseMessage);
Assert.IsNotNull(responseHeader);
// Change request data, with correct values.
Common.Api.Request.MediaHeader correctedRequestHeader = ResponseToRequest(responseHeader);
correctedRequestHeader.Name = "Breaking Bad (2008)";
correctedRequestHeader.Parts.ToArray()[0].Name = "Pilot";
// Update. Structures must have id's.
response = await Config.Client.PostAsync(Common.ApiRoutes.Media.Update,
new StringContent(
JsonSerializer.Serialize(correctedRequestHeader),
Encoding.UTF8, Config.HttpMediaTypeJson));
responseMessage = await response.Content.ReadAsStringAsync();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, responseMessage);
responseHeader = JsonSerializer.Deserialize <Common.Api.Response.MediaHeader>(responseMessage);
Assert.IsNotNull(responseHeader);
// Header
Assert.AreEqual("Breaking Bad (2008)", responseHeader.Name);
Assert.IsNotNull(responseHeader.Description);
Assert.IsTrue(responseHeader.Description.Length > 0);
// Parts
Assert.AreEqual(2, responseHeader.Parts.Count);
Assert.AreEqual("Pilot", responseHeader.Parts.ToArray()[0].Name);
Assert.AreEqual("Cat's in the Bag...", responseHeader.Parts.ToArray()[1].Name);
// Part[0] / Versions
Assert.AreEqual(1, responseHeader.Parts.ToArray()[0].Versions.Count);
Assert.AreEqual(2, responseHeader.Parts.ToArray()[0].Versions.ToArray()[0].Links.Count);
// Part[1] / Versions
Assert.AreEqual(1, responseHeader.Parts.ToArray()[1].Versions.Count);
Assert.AreEqual(2, responseHeader.Parts.ToArray()[1].Versions.ToArray()[0].Links.Count);
}
private async Task AddHeaderTagsAsync(Common.Api.Request.MediaHeader requestedHeader)
{
if (requestedHeader.Tags != null)
{
List <Dal.Model.MediaTag> tagsInRequestHeader = new();
foreach (var reqHeaderTag in requestedHeader.Tags)
{
var tag = await context.MediaTags.SingleOrDefaultAsync(t => t.Name == reqHeaderTag.Name);
if (tag == null)
{
tag = new Dal.Model.MediaTag {
Name = reqHeaderTag.Name
};
await context.MediaTags.AddAsync(tag);
await context.SaveChangesAsync();
}
tagsInRequestHeader.Add(tag);
// Header-Tag link
if (!await context.MediaHeaderTags.AnyAsync(ht => ht.MediaHeaderId == (int)requestedHeader.MediaHeaderId && ht.MediaTagId == tag.MediaTagId))
{
await context.MediaHeaderTags.AddAsync(new Dal.Model.MediaHeaderTag
{
MediaHeaderId = (int)requestedHeader.MediaHeaderId,
MediaTagId = tag.MediaTagId
});
await context.SaveChangesAsync();
}
}
// Remove tags that are not in request.
var allTagsForHeader = await context.MediaHeaderTags.Where(ht => ht.MediaHeaderId == (int)requestedHeader.MediaHeaderId).ToListAsync();
context.MediaHeaderTags.RemoveRange(allTagsForHeader.Where(headerTag => !tagsInRequestHeader.Any(requestTag => requestTag.MediaTagId == headerTag.MediaTagId)));
await context.SaveChangesAsync();
}
}
public async Task <ActionResult <Common.Api.Response.MediaHeader> > Update(Common.Api.Request.MediaHeader requestedHeader)
{
// Always check at beginning!
var loggedUser = await GetLoggedUserAsync();
if (loggedUser != null)
{
try
{
var addedMediaHeader = await AddOrUpdateHeaderAsync(requestedHeader, loggedUser);
return(Ok(await BuildResponseHeaderAsync(addedMediaHeader.MediaHeaderId)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
else
{
return(GetUnauthorizedLoginResponse());
}
}
public async Task Remove_One_Part_Tag()
{
// For the sake of sanity I'll use request object and convert it to JSON before calling API.
// Add wrong data.
HttpResponseMessage response = await Config.Client.PostAsync(Common.ApiRoutes.Media.Add,
new StringContent(
JsonSerializer.Serialize(ExampleRequest_BreakingBad()),
Encoding.UTF8, Config.HttpMediaTypeJson));
var responseMessage = await response.Content.ReadAsStringAsync();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, responseMessage);
Common.Api.Response.MediaHeader responseHeader = JsonSerializer.Deserialize <Common.Api.Response.MediaHeader>(responseMessage);
Assert.IsNotNull(responseHeader);
// Delete one tag from first part.
Common.Api.Request.MediaHeader updatedRequest = ResponseToRequest(responseHeader);
var part1Tags = ((List <Common.Api.Request.MediaTag>)((List <Common.Api.Request.MediaPart>)updatedRequest.Parts).First().Tags);
var oldPart1TagCount = part1Tags.Count;
part1Tags.Remove(part1Tags.LastOrDefault());
// Update. Structures must have id's.
response = await Config.Client.PostAsync(Common.ApiRoutes.Media.Update,
new StringContent(
JsonSerializer.Serialize(updatedRequest),
Encoding.UTF8, Config.HttpMediaTypeJson));
responseMessage = await response.Content.ReadAsStringAsync();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, responseMessage);
responseHeader = JsonSerializer.Deserialize <Common.Api.Response.MediaHeader>(responseMessage);
Assert.IsNotNull(responseHeader);
Assert.AreEqual(--oldPart1TagCount, ((IList <Common.Api.Response.MediaTag>)((IList <Common.Api.Response.MediaPart>)responseHeader.Parts).First().Tags).Count);
}
private async Task AddPartsAsync(Common.Api.Request.MediaHeader requestedHeader,
Dal.Model.MediaHeader addedHeader, Dal.Model.User loggedUser)
{
if (requestedHeader.Parts != null)
{
foreach (var requestedPart in requestedHeader.Parts)
{
Dal.Model.MediaPart part = requestedPart.MediaPartId == null ? new Dal.Model.MediaPart() :
await context.MediaParts.SingleOrDefaultAsync(p => p.MediaPartId == requestedPart.MediaPartId);
part.MediaHeaderId = addedHeader.MediaHeaderId;
part.Season = requestedPart.Season;
part.Episode = requestedPart.Episode;
part.Name = requestedPart.Name;
part.Description = requestedPart.Description;
part.ReferenceLink = !string.IsNullOrWhiteSpace(requestedPart.ReferenceLink) ? new Uri(requestedPart.ReferenceLink) : null;
part.UserId = loggedUser.UserId;
part.Created = DateTime.Now;
if (requestedPart.MediaPartId == null)
{
await context.MediaParts.AddAsync(part);
}
await context.SaveChangesAsync();
requestedPart.MediaPartId = part.MediaPartId;
// Part tags
await AddPartTagsAsync(requestedPart);
// Media versions and tags
await AddVersionAsync(requestedPart, part, loggedUser);
}
}
}
private static void CompareRequestAndResponse(Common.Api.Request.MediaHeader requestMedia, Common.Api.Response.MediaHeader responseMedia)
{
// Header
Assert.AreEqual(requestMedia.Name, responseMedia.Name);
Assert.AreEqual(requestMedia.Year, responseMedia.Year);
Assert.AreEqual(requestMedia.Description, responseMedia.Description);
Assert.AreEqual(requestMedia.ReferenceLink, responseMedia.ReferenceLink);
if (requestMedia.Tags != null)
{
Assert.AreEqual(requestMedia.Tags.Count, responseMedia.Tags.Count);
foreach (var requestTag in requestMedia.Tags)
{
Assert.IsTrue((responseMedia.Tags as IList <Common.Api.Response.MediaTag>).Any(responseTag => responseTag.Name == requestTag.Name));
}
}
// Parts
if (requestMedia.Parts != null)
{
Assert.AreEqual(requestMedia.Parts.Count, responseMedia.Parts.Count);
foreach (var requestPart in requestMedia.Parts)
{
var responsePart = responseMedia.Parts.SingleOrDefault(p => p.Season == requestPart.Season && p.Episode == requestPart.Episode);
Assert.IsNotNull(responsePart, "Can't find response part.");
if (requestPart.Name != null)
{
Assert.AreEqual(requestPart.Name, responsePart.Name);
}
if (requestPart.Description != null)
{
Assert.AreEqual(requestPart.Description, responsePart.Description);
}
if (requestPart.ReferenceLink != null)
{
Assert.AreEqual(requestPart.ReferenceLink, responsePart.ReferenceLink);
}
// Part Tags
if (requestPart.Tags != null)
{
Assert.AreEqual(requestPart.Tags.Count, responsePart.Tags.Count);
foreach (var requestTag in requestPart.Tags)
{
Assert.IsTrue((responsePart.Tags as IList <Common.Api.Response.MediaTag>).Any(responseTag => responseTag.Name == requestTag.Name));
}
}
// Version
Assert.AreEqual(requestPart.Version.VersionComment, responsePart.Versions.FirstOrDefault().VersionComment);
// Version Tags
if (requestPart.Version.Tags != null)
{
Assert.AreEqual(requestPart.Version.Tags.Count, responsePart.Versions.FirstOrDefault().Tags.Count);
foreach (var requestTag in requestPart.Version.Tags)
{
Assert.IsTrue((responsePart.Versions.FirstOrDefault().Tags as IList <Common.Api.Response.MediaTag>).Any(responseTag => responseTag.Name == requestTag.Name));
}
}
// Links
Assert.AreEqual(requestPart.Version.Links.Count, responsePart.Versions.FirstOrDefault().Links.Count);
foreach (var requestLink in requestPart.Version.Links)
{
var responseLink = responsePart.Versions.FirstOrDefault().Links.SingleOrDefault(l => l.LinkOrderId == requestLink.LinkOrderId);
Assert.IsNotNull(responseLink);
Assert.AreEqual(requestLink.Link, responseLink.Link);
}
}
}
}
