MateuszSkoczek/WatchIt
1
0
Fork 0
Code Issues Pull Requests Actions Projects Wiki Activity

new photos controller created

Browse Source
This commit is contained in:
Mateusz Skoczek
2024-09-25 22:11:28 +02:00
Unverified
parent bb67186587
commit 9e9e5e1742
36 changed files with 743 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/MediaController.cs
View File

@@ -4,33 +4,53 @@ using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WatchIt.Common.Model.Genres;
using WatchIt.Common.Model.Media;
using WatchIt.Common.Model.Photos;
using WatchIt.WebAPI.Services.Controllers.Media;
namespace WatchIt.WebAPI.Controllers;
[ApiController]
[Route("media")]
public class MediaController(IMediaControllerService mediaControllerService)
public class MediaController : ControllerBase
{
#region MAIN
#region FIELDS
[HttpGet("{id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMedia([FromRoute] long id) => await mediaControllerService.GetMedia(id);
private readonly IMediaControllerService _mediaControllerService;
#endregion
#region GENRES
#region CONSTRUCTORS
public MediaController(IMediaControllerService mediaControllerService)
{
_mediaControllerService = mediaControllerService;
}
#endregion
#region METHODS
#region Main
[HttpGet("{id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMedia([FromRoute] long id) => await _mediaControllerService.GetMedia(id);
#endregion
#region Genres
[HttpGet("{id}/genres")]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<GenreResponse>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaGenres([FromRoute]long id) => await mediaControllerService.GetMediaGenres(id);
public async Task<ActionResult> GetMediaGenres([FromRoute]long id) => await _mediaControllerService.GetMediaGenres(id);
[HttpPost("{id}/genres/{genre_id}")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
@@ -38,7 +58,7 @@ public class MediaController(IMediaControllerService mediaControllerService)
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PostMediaGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await mediaControllerService.PostMediaGenre(id, genreId);
public async Task<ActionResult> PostMediaGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await _mediaControllerService.PostMediaGenre(id, genreId);
[HttpDelete("{id}/genres/{genre_id}")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
@@ -46,25 +66,23 @@ public class MediaController(IMediaControllerService mediaControllerService)
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> DeleteMediaGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await mediaControllerService.DeleteMediaGenre(id, genreId);
public async Task<ActionResult> DeleteMediaGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await _mediaControllerService.DeleteMediaGenre(id, genreId);
#endregion
#region RATING
#region Rating
[HttpGet("{id}/rating")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaRatingResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaRating([FromRoute] long id) => await mediaControllerService.GetMediaRating(id);
public async Task<ActionResult> GetMediaRating([FromRoute] long id) => await _mediaControllerService.GetMediaRating(id);
[HttpGet("{id}/rating/{user_id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(short), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaRatingByUser([FromRoute] long id, [FromRoute(Name = "user_id")]long userId) => await mediaControllerService.GetMediaRatingByUser(id, userId);
public async Task<ActionResult> GetMediaRatingByUser([FromRoute] long id, [FromRoute(Name = "user_id")]long userId) => await _mediaControllerService.GetMediaRatingByUser(id, userId);
[HttpPut("{id}/rating")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
@@ -72,38 +90,34 @@ public class MediaController(IMediaControllerService mediaControllerService)
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PutMediaRating([FromRoute] long id, [FromBody] MediaRatingRequest data) => await mediaControllerService.PutMediaRating(id, data);
public async Task<ActionResult> PutMediaRating([FromRoute] long id, [FromBody] MediaRatingRequest data) => await _mediaControllerService.PutMediaRating(id, data);
[HttpDelete("{id}/rating")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
public async Task<ActionResult> DeleteMediaRating([FromRoute] long id) => await mediaControllerService.DeleteMediaRating(id);
public async Task<ActionResult> DeleteMediaRating([FromRoute] long id) => await _mediaControllerService.DeleteMediaRating(id);
#endregion
#region VIEW COUNT
#region View count
[HttpPost("{id}/view")]
[AllowAnonymous]
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PostMediaView([FromRoute] long id) => await mediaControllerService.PostMediaView(id);
public async Task<ActionResult> PostMediaView([FromRoute] long id) => await _mediaControllerService.PostMediaView(id);
#endregion
#region POSTER
#region Poster
[HttpGet("{id}/poster")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaPosterResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaPoster([FromRoute] long id) => await mediaControllerService.GetMediaPoster(id);
public async Task<ActionResult> GetMediaPoster([FromRoute] long id) => await _mediaControllerService.GetMediaPoster(id);
[HttpPut("{id}/poster")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
@@ -111,68 +125,41 @@ public class MediaController(IMediaControllerService mediaControllerService)
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> PutMediaPoster([FromRoute]long id, [FromBody]MediaPosterRequest body) => await mediaControllerService.PutMediaPoster(id, body);
public async Task<ActionResult> PutMediaPoster([FromRoute]long id, [FromBody]MediaPosterRequest body) => await _mediaControllerService.PutMediaPoster(id, body);
[HttpDelete("{id}/poster")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status204NoContent)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> DeleteMediaPoster([FromRoute]long id) => await mediaControllerService.DeleteMediaPoster(id);
public async Task<ActionResult> DeleteMediaPoster([FromRoute]long id) => await _mediaControllerService.DeleteMediaPoster(id);
#endregion
#region Photos
#region PHOTOS
[HttpGet("{id}/photos")]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<PhotoResponse>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaPhotos([FromRoute]long id, PhotoQueryParameters query) => await _mediaControllerService.GetMediaPhotos(id, query);
[HttpGet("{id}/photos/random_background")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaPhotoResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(PhotoResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetMediaPhotoRandomBackground([FromRoute]long id) => await mediaControllerService.GetMediaRandomBackgroundPhoto(id);
public async Task<ActionResult> GetMediaPhotoRandomBackground([FromRoute]long id) => await _mediaControllerService.GetMediaPhotoRandomBackground(id);
[HttpGet("photos/{photo_id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaPhotoResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetPhoto([FromRoute(Name = "photo_id")] Guid photoId) => await mediaControllerService.GetPhoto(photoId);
[HttpGet("photos")]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<MediaPhotoResponse>), StatusCodes.Status200OK)]
public async Task<ActionResult> GetPhotos(MediaPhotoQueryParameters query) => await mediaControllerService.GetPhotos(query);
[HttpGet("photos/random_background")]
[AllowAnonymous]
[ProducesResponseType(typeof(MediaPhotoResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetPhotoRandomBackground() => await mediaControllerService.GetRandomBackgroundPhoto();
[HttpPost("photos")]
[HttpPost("{id}/photos")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(MediaPhotoResponse), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> PostPhoto([FromBody]MediaPhotoRequest body) => await mediaControllerService.PostPhoto(body);
[HttpPut("photos/{photo_id}")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(PhotoResponse), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PutPhoto([FromRoute(Name = "photo_id")]Guid photoId, [FromBody]MediaPhotoRequest body) => await mediaControllerService.PutPhoto(photoId, body);
public async Task<ActionResult> PostPhoto([FromRoute]long id, [FromBody]MediaPhotoRequest body) => await _mediaControllerService.PostMediaPhoto(id, body);
[HttpDelete("photos/{photo_id}")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> DeletePhoto([FromRoute(Name = "photo_id")]Guid photoId) => await mediaControllerService.DeletePhoto(photoId);
#endregion
#endregion
}

74
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/PhotosController.cs Normal file
View File

@@ -0,0 +1,74 @@
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WatchIt.Common.Model.Photos;
using WatchIt.WebAPI.Services.Controllers.Photos;
namespace WatchIt.WebAPI.Controllers;
[ApiController]
[Route("photos")]
public class PhotosController : ControllerBase
{
#region FIELDS
private readonly IPhotosControllerService _photosControllerService;
#endregion
#region CONSTRUCTORS
public PhotosController(IPhotosControllerService photosControllerService)
{
_photosControllerService = photosControllerService;
}
#endregion
#region METHODS
#region Main
[HttpGet("random_background")]
[AllowAnonymous]
[ProducesResponseType(typeof(PhotoResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetPhotoRandomBackground() => await _photosControllerService.GetPhotoRandomBackground();
[HttpDelete("{id}")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> DeletePhoto([FromRoute] Guid id) => await _photosControllerService.DeletePhoto(id);
#endregion
#region Background data
[HttpPut("{id}/background_data")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PutPhotoBackgroundData([FromRoute]Guid id, [FromBody] PhotoBackgroundDataRequest body) => await _photosControllerService.PutPhotoBackgroundData(id, body);
[HttpDelete("{id}/background_data")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> DeletePhotoBackgroundData([FromRoute]Guid id) => await _photosControllerService.DeletePhotoBackgroundData(id);
#endregion
#endregion
}

1
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/WatchIt.WebAPI.Controllers.csproj
View File

@@ -17,6 +17,7 @@
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Genres\WatchIt.WebAPI.Services.Controllers.Genres.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Media\WatchIt.WebAPI.Services.Controllers.Media.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Movies\WatchIt.WebAPI.Services.Controllers.Movies.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Photos\WatchIt.WebAPI.Services.Controllers.Photos.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Series\WatchIt.WebAPI.Services.Controllers.Series.csproj" />
</ItemGroup>

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Media/IMediaControllerService.cs
View File

@@ -1,4 +1,5 @@
using WatchIt.Common.Model.Media;
using WatchIt.Common.Model.Photos;
using WatchIt.WebAPI.Services.Controllers.Common;
namespace WatchIt.WebAPI.Services.Controllers.Media;
@@ -21,12 +22,8 @@ public interface IMediaControllerService
Task<RequestResult> GetMediaPoster(long mediaId);
Task<RequestResult> PutMediaPoster(long mediaId, MediaPosterRequest data);
Task<RequestResult> DeleteMediaPoster(long mediaId);
Task<RequestResult> GetPhoto(Guid id);
Task<RequestResult> GetPhotos(MediaPhotoQueryParameters query);
Task<RequestResult> GetRandomBackgroundPhoto();
Task<RequestResult> GetMediaRandomBackgroundPhoto(long id);
Task<RequestResult> PostPhoto(MediaPhotoRequest data);
Task<RequestResult> PutPhoto(Guid photoId, MediaPhotoRequest data);
Task<RequestResult> DeletePhoto(Guid photoId);
Task<RequestResult> GetMediaPhotos(long mediaId, PhotoQueryParameters queryParameters);
Task<RequestResult> GetMediaPhotoRandomBackground(long mediaId);
Task<RequestResult> PostMediaPhoto(long mediaId, MediaPhotoRequest data);
}

116
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Media/MediaControllerService.cs
View File

@@ -2,6 +2,7 @@
using SimpleToolkit.Extensions;
using WatchIt.Common.Model.Genres;
using WatchIt.Common.Model.Media;
using WatchIt.Common.Model.Photos;
using WatchIt.Database;
using WatchIt.Database.Model.Media;
using WatchIt.Database.Model.Rating;
@@ -294,59 +295,48 @@ public class MediaControllerService(DatabaseContext database, IUserService userS
#endregion
#region Photos
public async Task<RequestResult> GetPhoto(Guid id)
public async Task<RequestResult> GetMediaPhotos(long mediaId, PhotoQueryParameters queryParameters)
{
MediaPhotoImage? item = await database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
Database.Model.Media.Media? media = await database.Media.FirstOrDefaultAsync(x => x.Id == mediaId);
if (media is null)
{
return RequestResult.NotFound();
}
MediaPhotoResponse data = new MediaPhotoResponse(item);
return RequestResult.Ok(data);
IEnumerable<MediaPhotoImage> imagesRaw = await database.MediaPhotoImages.Where(x => x.MediaId == mediaId).ToListAsync();
IEnumerable<PhotoResponse> images = imagesRaw.Select(x => new PhotoResponse(x));
images = queryParameters.PrepareData(images);
return RequestResult.Ok(images);
}
public async Task<RequestResult> GetPhotos(MediaPhotoQueryParameters query)
public Task<RequestResult> GetMediaPhotoRandomBackground(long mediaId)
{
IEnumerable<MediaPhotoResponse> data = await database.MediaPhotoImages.Select(x => new MediaPhotoResponse(x)).ToListAsync();
data = query.PrepareData(data);
return RequestResult.Ok(data);
}
public Task<RequestResult> GetRandomBackgroundPhoto()
{
MediaPhotoImage? image = database.MediaPhotoImages.Where(x => x.MediaPhotoImageBackground != null && x.MediaPhotoImageBackground.IsUniversalBackground).Random();
MediaPhotoImage? image = database.MediaPhotoImages.Where(x => x.MediaId == mediaId && x.MediaPhotoImageBackground != null).Random();
if (image is null)
{
return Task.FromResult<RequestResult>(RequestResult.NotFound());
}
MediaPhotoResponse data = new MediaPhotoResponse(image);
return Task.FromResult<RequestResult>(RequestResult.Ok(data));
}
public Task<RequestResult> GetMediaRandomBackgroundPhoto(long id)
{
MediaPhotoImage? image = database.MediaPhotoImages.Where(x => x.MediaId == id && x.MediaPhotoImageBackground != null).Random();
if (image is null)
{
return Task.FromResult<RequestResult>(RequestResult.NotFound());
}
MediaPhotoResponse data = new MediaPhotoResponse(image);
PhotoResponse data = new PhotoResponse(image);
return Task.FromResult<RequestResult>(RequestResult.Ok(data));
}
public async Task<RequestResult> PostPhoto(MediaPhotoRequest data)
public async Task<RequestResult> PostMediaPhoto(long mediaId, MediaPhotoRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
Database.Model.Media.Media? media = await database.Media.FirstOrDefaultAsync(x => x.Id == mediaId);
if (media is null)
{
return RequestResult.NotFound();
}
MediaPhotoImage item = data.CreateMediaPhotoImage();
MediaPhotoImage item = data.CreateMediaPhotoImage(mediaId);
await database.MediaPhotoImages.AddAsync(item);
await database.SaveChangesAsync();
@@ -357,69 +347,7 @@ public class MediaControllerService(DatabaseContext database, IUserService userS
await database.SaveChangesAsync();
}
return RequestResult.Created($"photos/{item.Id}", new MediaPhotoResponse(item));
}
public async Task<RequestResult> PutPhoto(Guid photoId, MediaPhotoRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaPhotoImage? item = await database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == photoId);
if (item is null)
{
return RequestResult.NotFound();
}
data.UpdateMediaPhotoImage(item);
if (item.MediaPhotoImageBackground is null && data.Background is not null)
{
MediaPhotoImageBackground background = data.CreateMediaPhotoImageBackground(item.Id)!;
await database.MediaPhotoImageBackgrounds.AddAsync(background);
}
else if (item.MediaPhotoImageBackground is not null && data.Background is null)
{
database.MediaPhotoImageBackgrounds.Attach(item.MediaPhotoImageBackground);
database.MediaPhotoImageBackgrounds.Remove(item.MediaPhotoImageBackground);
}
else if (item.MediaPhotoImageBackground is not null && data.Background is not null)
{
data.UpdateMediaPhotoImageBackground(item.MediaPhotoImageBackground);
}
await database.SaveChangesAsync();
return RequestResult.Ok();
}
public async Task<RequestResult> DeletePhoto(Guid photoId)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaPhotoImage? item = await database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == photoId);
if (item is null)
{
return RequestResult.NotFound();
}
if (item.MediaPhotoImageBackground is not null)
{
database.MediaPhotoImageBackgrounds.Attach(item.MediaPhotoImageBackground);
database.MediaPhotoImageBackgrounds.Remove(item.MediaPhotoImageBackground);
await database.SaveChangesAsync();
}
database.MediaPhotoImages.Attach(item);
database.MediaPhotoImages.Remove(item);
await database.SaveChangesAsync();
return RequestResult.Ok();
return RequestResult.Created($"photos/{item.Id}", new PhotoResponse(item));
}
#endregion

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Photos/IPhotosControllerService.cs Normal file
View File

@@ -0,0 +1,13 @@
using WatchIt.Common.Model.Photos;
using WatchIt.WebAPI.Services.Controllers.Common;
namespace WatchIt.WebAPI.Services.Controllers.Photos;
public interface IPhotosControllerService
{
Task<RequestResult> GetPhotoRandomBackground();
Task<RequestResult> DeletePhoto(Guid photoId);
Task<RequestResult> PutPhotoBackgroundData(Guid id, PhotoBackgroundDataRequest data);
Task<RequestResult> DeletePhotoBackgroundData(Guid id);
}

140
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Photos/PhotosControllerService.cs Normal file
View File

@@ -0,0 +1,140 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using SimpleToolkit.Extensions;
using WatchIt.Common.Model.Photos;
using WatchIt.Database;
using WatchIt.Database.Model.Media;
using WatchIt.WebAPI.Services.Controllers.Common;
using WatchIt.WebAPI.Services.Utility.User;
namespace WatchIt.WebAPI.Services.Controllers.Photos;
public class PhotosControllerService : IPhotosControllerService
{
#region FIELDS
private readonly DatabaseContext _database;
private readonly IUserService _userService;
#endregion
#region CONTRUCTORS
public PhotosControllerService(DatabaseContext database, IUserService userService)
{
_database = database;
_userService = userService;
}
#endregion
#region PUBLIC METHODS
#region Main
public Task<RequestResult> GetPhotoRandomBackground()
{
MediaPhotoImage? image = _database.MediaPhotoImages.Where(x => x.MediaPhotoImageBackground != null && x.MediaPhotoImageBackground.IsUniversalBackground).Random();
if (image is null)
{
return Task.FromResult<RequestResult>(RequestResult.NotFound());
}
PhotoResponse data = new PhotoResponse(image);
return Task.FromResult<RequestResult>(RequestResult.Ok(data));
}
public async Task<RequestResult> DeletePhoto(Guid photoId)
{
UserValidator validator = _userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaPhotoImage? item = await _database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == photoId);
if (item is null)
{
return RequestResult.NotFound();
}
if (item.MediaPhotoImageBackground is not null)
{
_database.MediaPhotoImageBackgrounds.Attach(item.MediaPhotoImageBackground);
_database.MediaPhotoImageBackgrounds.Remove(item.MediaPhotoImageBackground);
await _database.SaveChangesAsync();
}
_database.MediaPhotoImages.Attach(item);
_database.MediaPhotoImages.Remove(item);
await _database.SaveChangesAsync();
return RequestResult.Ok();
}
#endregion
#region Background data
public async Task<RequestResult> PutPhotoBackgroundData(Guid id, PhotoBackgroundDataRequest data)
{
UserValidator validator = _userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaPhotoImage? image = await _database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == id);
if (image is null)
{
return RequestResult.NotFound();
}
MediaPhotoImageBackground? imageBackground = image.MediaPhotoImageBackground;
if (imageBackground is null)
{
imageBackground = data.CreateMediaPhotoImageBackground(id);
await _database.MediaPhotoImageBackgrounds.AddAsync(imageBackground);
}
else
{
data.UpdateMediaPhotoImageBackground(imageBackground);
}
await _database.SaveChangesAsync();
return RequestResult.Ok();
}
public async Task<RequestResult> DeletePhotoBackgroundData(Guid id)
{
UserValidator validator = _userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaPhotoImage? image = await _database.MediaPhotoImages.FirstOrDefaultAsync(x => x.Id == id);
if (image is null)
{
return RequestResult.NotFound();
}
MediaPhotoImageBackground? imageBackground = image.MediaPhotoImageBackground;
if (imageBackground is not null)
{
_database.MediaPhotoImageBackgrounds.Attach(imageBackground);
_database.MediaPhotoImageBackgrounds.Remove(imageBackground);
await _database.SaveChangesAsync();
}
return RequestResult.Ok();
}
#endregion
#endregion
}

20
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Photos/WatchIt.WebAPI.Services.Controllers.Photos.csproj Normal file
View File

@@ -0,0 +1,20 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\WatchIt.Common\WatchIt.Common.Model\WatchIt.Common.Model.csproj" />
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\..\WatchIt.WebAPI.Services.Utility\WatchIt.WebAPI.Services.Utility.User\WatchIt.WebAPI.Services.Utility.User.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services.Controllers.Common\WatchIt.WebAPI.Services.Controllers.Common.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="SimpleToolkit.Extensions" Version="1.7.7" />
</ItemGroup>
</Project>

1
WatchIt.WebAPI/WatchIt.WebAPI.Validators/Media/MediaPhotoRequestValidator.cs
View File

@@ -9,7 +9,6 @@ public class MediaPhotoRequestValidator : AbstractValidator<MediaPhotoRequest>
{
public MediaPhotoRequestValidator(DatabaseContext database)
{
RuleFor(x => x.MediaId).MustBeIn(database.Media, x => x.Id).WithMessage("Media does not exists");
RuleFor(x => x.Image).NotEmpty();
RuleFor(x => x.MimeType).Matches(@"\w+/.+").WithMessage("Incorrect mimetype");
When(x => x.Background is not null, () =>

2
WatchIt.WebAPI/WatchIt.WebAPI/Program.cs
View File

@@ -13,6 +13,7 @@ using WatchIt.WebAPI.Services.Controllers.Accounts;
using WatchIt.WebAPI.Services.Controllers.Genres;
using WatchIt.WebAPI.Services.Controllers.Media;
using WatchIt.WebAPI.Services.Controllers.Movies;
using WatchIt.WebAPI.Services.Controllers.Photos;
using WatchIt.WebAPI.Services.Controllers.Series;
using WatchIt.WebAPI.Services.Utility.Configuration;
using WatchIt.WebAPI.Services.Utility.Tokens;
@@ -156,6 +157,7 @@ public static class Program
builder.Services.AddTransient<IMoviesControllerService, MoviesControllerService>();
builder.Services.AddTransient<IMediaControllerService, MediaControllerService>();
builder.Services.AddTransient<ISeriesControllerService, SeriesControllerService>();
builder.Services.AddTransient<IPhotosControllerService, PhotosControllerService>();
return builder;
}