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

project reorganized

Browse Source
This commit is contained in:
Mateusz Skoczek
2024-04-27 22:36:16 +02:00
Unverified
parent fcca2119a5
commit 4b333878b8
233 changed files with 4916 additions and 11471 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/AccountsController.cs
View File

@@ -1,47 +1,33 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using WatchIt.Shared.Models.Accounts.Authenticate;
using WatchIt.Shared.Models.Accounts.Register;
using WatchIt.WebAPI.Services.Controllers;
using WatchIt.Common.Model.Accounts;
using WatchIt.WebAPI.Services.Controllers.Accounts;
namespace WatchIt.WebAPI.Controllers
namespace WatchIt.WebAPI.Controllers;
[ApiController]
[Route("accounts")]
public class AccountsController(IAccountsControllerService accountsControllerService) : ControllerBase
{
[ApiController]
[Route("api/accounts")]
public class AccountsController(IAccountsControllerService accountsControllerService) : ControllerBase
{
#region METHODS
[HttpPost]
[Route("register")]
[AllowAnonymous]
[ProducesResponseType(typeof(RegisterResponse), StatusCodes.Status201Created)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<ActionResult> Register([FromBody] RegisterRequest data) => await accountsControllerService.Register(data);
[HttpPost]
[Route("authenticate")]
[AllowAnonymous]
[ProducesResponseType(typeof(AuthenticateResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status401Unauthorized)]
public async Task<ActionResult> Authenticate([FromBody] AuthenticateRequest data) => await accountsControllerService.Authenticate(data);
[HttpPost]
[Route("authenticate-refresh")]
[Authorize(AuthenticationSchemes = "refresh")]
[ProducesResponseType(typeof(AuthenticateResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status401Unauthorized)]
public async Task<ActionResult> AuthenticateRefresh() => await accountsControllerService.AuthenticateRefresh();
#endregion
}
}
[HttpPost("register")]
[AllowAnonymous]
[ProducesResponseType(typeof(RegisterResponse), StatusCodes.Status201Created)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<ActionResult> Register([FromBody]RegisterRequest body) => await accountsControllerService.Register(body);
[HttpPost("authenticate")]
[AllowAnonymous]
[ProducesResponseType(typeof(AuthenticateResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
public async Task<ActionResult> Authenticate([FromBody]AuthenticateRequest body) => await accountsControllerService.Authenticate(body);
[HttpPost("authenticate-refresh")]
[Authorize(AuthenticationSchemes = "refresh")]
[ProducesResponseType(typeof(AuthenticateResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> AuthenticateRefresh() => await accountsControllerService.AuthenticateRefresh();
}

48
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/GenresController.cs Normal file
View File

@@ -0,0 +1,48 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WatchIt.Common.Model.Genres;
using WatchIt.WebAPI.Services.Controllers.Genres;
namespace WatchIt.WebAPI.Controllers;
[ApiController]
[Route("genres")]
public class GenresController(IGenresControllerService genresControllerService) : ControllerBase
{
[HttpGet]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<GenreResponse>), StatusCodes.Status200OK)]
public async Task<ActionResult> GetAll(GenreQueryParameters query) => await genresControllerService.GetAll(query);
[HttpGet("{id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(GenreResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> Get([FromRoute]short id) => await genresControllerService.Get(id);
[HttpPost]
[Authorize]
[ProducesResponseType(typeof(GenreResponse), StatusCodes.Status201Created)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> Post([FromBody]GenreRequest body) => await genresControllerService.Post(body);
[HttpPut("{id}")]
[Authorize]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> Put([FromRoute]short id, [FromBody]GenreRequest body) => await genresControllerService.Put(id, body);
[HttpDelete("{id}")]
[Authorize]
[ProducesResponseType(typeof(GenreResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> Delete([FromRoute]short id) => await genresControllerService.Delete(id);
}

68
WatchIt.WebAPI/WatchIt.WebAPI.Controllers/MoviesController.cs Normal file
View File

@@ -0,0 +1,68 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WatchIt.Common.Model.Genres;
using WatchIt.Common.Model.Movies;
using WatchIt.WebAPI.Services.Controllers.Movies;
namespace WatchIt.WebAPI.Controllers;
[ApiController]
[Route("movies")]
public class MoviesController(IMoviesControllerService moviesControllerService) : ControllerBase
{
[HttpGet]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<MovieResponse>), StatusCodes.Status200OK)]
public async Task<ActionResult> GetAll(MovieQueryParameters query) => await moviesControllerService.GetAll(query);
[HttpGet("{id}")]
[AllowAnonymous]
[ProducesResponseType(typeof(MovieResponse), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> Get([FromRoute]long id) => await moviesControllerService.Get(id);
[HttpPost]
[Authorize]
[ProducesResponseType(typeof(MovieResponse), StatusCodes.Status201Created)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> Post([FromBody]MovieRequest body) => await moviesControllerService.Post(body);
[HttpPut("{id}")]
[Authorize]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> Put([FromRoute]long id, [FromBody]MovieRequest body) => await moviesControllerService.Put(id, body);
[HttpDelete("{id}")]
[Authorize]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
public async Task<ActionResult> Delete([FromRoute]long id) => await moviesControllerService.Delete(id);
[HttpGet("{id}/genres")]
[AllowAnonymous]
[ProducesResponseType(typeof(IEnumerable<GenreResponse>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> GetGenres([FromRoute]long id) => await moviesControllerService.GetGenres(id);
[HttpPost("{id}/genres/{genre_id}")]
[Authorize]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> PostGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await moviesControllerService.PostGenre(id, genreId);
[HttpDelete("{id}/genres/{genre_id}")]
[Authorize]
[ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
[ProducesResponseType(typeof(void), StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<ActionResult> DeleteGenre([FromRoute]long id, [FromRoute(Name = "genre_id")]short genreId) => await moviesControllerService.DeleteGenre(id, genreId);
}

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

@@ -1,18 +1,20 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Mvc.Core" Version="2.2.5" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.3" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.csproj" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WatchIt.Common\WatchIt.Common.Model\WatchIt.Common.Model.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Controllers\WatchIt.WebAPI.Services.Controllers.Accounts\WatchIt.WebAPI.Services.Controllers.Accounts.csproj" />
<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.Movies\WatchIt.WebAPI.Services.Controllers.Movies.csproj" />
</ItemGroup>
</Project>

88
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/AccountsControllerService.cs
View File

@@ -1,88 +0,0 @@
using Microsoft.EntityFrameworkCore;
using SimpleToolkit.Extensions;
using System.Security.Cryptography;
using System.Text;
using WatchIt.Database;
using WatchIt.Database.Model.Account;
using WatchIt.Shared.Models;
using WatchIt.Shared.Models.Accounts.Authenticate;
using WatchIt.Shared.Models.Accounts.Register;
using WatchIt.WebAPI.Services.Utility.JWT;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace WatchIt.WebAPI.Services.Controllers
{
public interface IAccountsControllerService
{
Task<RequestResult<RegisterResponse>> Register(RegisterRequest data);
Task<RequestResult<AuthenticateResponse>> Authenticate(AuthenticateRequest data);
Task<RequestResult<AuthenticateResponse>> AuthenticateRefresh();
}
public class AccountsControllerService(IJWTService jwtService, DatabaseContext database) : IAccountsControllerService
{
#region PUBLIC METHODS
public async Task<RequestResult<RegisterResponse>> Register(RegisterRequest data)
{
string leftSalt = StringExtensions.CreateRandom(20);
string rightSalt = StringExtensions.CreateRandom(20);
byte[] hash = ComputeHash(data.Password, leftSalt, rightSalt);
Account account = new Account
{
Username = data.Username,
Email = data.Email,
Password = hash,
LeftSalt = leftSalt,
RightSalt = rightSalt
};
await database.Accounts.AddAsync(account);
await database.SaveChangesAsync();
return RequestResult.Created<RegisterResponse>($"accounts/{account.Id}", account);
}
public async Task<RequestResult<AuthenticateResponse>> Authenticate(AuthenticateRequest data)
{
Account? account = await database.Accounts.FirstOrDefaultAsync(x => string.Equals(x.Email, data.UsernameOrEmail) || string.Equals(x.Username, data.UsernameOrEmail));
if (account is null)
{
return RequestResult.Unauthorized<AuthenticateResponse>("User does not exists");
}
byte[] hash = ComputeHash(data.Password, account.LeftSalt, account.RightSalt);
if (!Enumerable.SequenceEqual(hash, account.Password))
{
return RequestResult.Unauthorized<AuthenticateResponse>("Incorrect password");
}
Task<string> refreshTokenTask = jwtService.CreateRefreshToken(account, true);
Task<string> accessTokenTask = jwtService.CreateAccessToken(account);
await Task.WhenAll(refreshTokenTask, accessTokenTask);
AuthenticateResponse response = new AuthenticateResponse
{
AccessToken = accessTokenTask.Result,
RefreshToken = refreshTokenTask.Result,
};
return RequestResult.Ok(response);
}
public async Task<RequestResult<AuthenticateResponse>> AuthenticateRefresh()
{
}
#endregion
#region PRIVATE METHODS
protected byte[] ComputeHash(string password, string leftSalt, string rightSalt) => SHA512.Create().ComputeHash(Encoding.UTF8.GetBytes($"{leftSalt}{password}{rightSalt}"));
#endregion
}
}

109
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Accounts/AccountsControllerService.cs Normal file
View File

@@ -0,0 +1,109 @@
using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using SimpleToolkit.Extensions;
using WatchIt.Common.Model.Accounts;
using WatchIt.Database;
using WatchIt.Database.Model.Account;
using WatchIt.WebAPI.Services.Controllers.Common;
using WatchIt.WebAPI.Services.Utility.Tokens;
using WatchIt.WebAPI.Services.Utility.Tokens.Exceptions;
using WatchIt.WebAPI.Services.Utility.User;
namespace WatchIt.WebAPI.Services.Controllers.Accounts;
public class AccountsControllerService(
ILogger<AccountsControllerService> logger,
DatabaseContext database,
ITokensService tokensService,
IUserService userService
) : IAccountsControllerService
{
#region PUBLIC METHODS
public async Task<RequestResult> Register(RegisterRequest data)
{
string leftSalt = StringExtensions.CreateRandom(20);
string rightSalt = StringExtensions.CreateRandom(20);
byte[] hash = ComputeHash(data.Password, leftSalt, rightSalt);
Account account = new Account
{
Username = data.Username,
Email = data.Email,
Password = hash,
LeftSalt = leftSalt,
RightSalt = rightSalt,
};
await database.Accounts.AddAsync(account);
await database.SaveChangesAsync();
logger.LogInformation($"New account with ID {account.Id} was created (username: {account.Username}; email: {account.Email})");
return RequestResult.Created($"accounts/{account.Id}", new RegisterResponse(account));
}
public async Task<RequestResult> Authenticate(AuthenticateRequest data)
{
Account? account = await database.Accounts.FirstOrDefaultAsync(x => string.Equals(x.Email, data.UsernameOrEmail) || string.Equals(x.Username, data.UsernameOrEmail));
if (account is null || !ComputeHash(data.Password, account.LeftSalt, account.RightSalt).SequenceEqual(account.Password))
{
return RequestResult.Unauthorized();
}
Task<string> refreshTokenTask = tokensService.CreateRefreshTokenAsync(account, true);
Task<string> accessTokenTask = tokensService.CreateAccessTokenAsync(account);
AuthenticateResponse response = new AuthenticateResponse
{
AccessToken = await accessTokenTask,
RefreshToken = await refreshTokenTask,
};
logger.LogInformation($"Account with ID {account.Id} was authenticated");
return RequestResult.Ok(response);
}
public async Task<RequestResult> AuthenticateRefresh()
{
Guid jti = userService.GetJti();
AccountRefreshToken? token = await database.AccountRefreshTokens.FirstOrDefaultAsync(x => x.Id == jti);
if (token is null || token.ExpirationDate < DateTime.UtcNow)
{
return RequestResult.Unauthorized();
}
AuthenticateResponse response;
try
{
Task<string> refreshTokenTask = tokensService.ExtendRefreshTokenAsync(token.Account, token.Id);
Task<string> accessTokenTask = tokensService.CreateAccessTokenAsync(token.Account);
response = new AuthenticateResponse
{
AccessToken = await accessTokenTask,
RefreshToken = await refreshTokenTask,
};
}
catch (TokenNotFoundException)
{
return RequestResult.Unauthorized();
}
catch (TokenNotExtendableException)
{
return RequestResult.Forbidden();
}
logger.LogInformation($"Account with ID {token.AccountId} was authenticated by token refreshing");
return RequestResult.Ok(response);
}
#endregion
#region PRIVATE METHODS
protected byte[] ComputeHash(string password, string leftSalt, string rightSalt) => SHA512.HashData(Encoding.UTF8.GetBytes($"{leftSalt}{password}{rightSalt}"));
#endregion
}

11
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Accounts/IAccountsControllerService.cs Normal file
View File

@@ -0,0 +1,11 @@
using WatchIt.Common.Model.Accounts;
using WatchIt.WebAPI.Services.Controllers.Common;
namespace WatchIt.WebAPI.Services.Controllers.Accounts;
public interface IAccountsControllerService
{
Task<RequestResult> Register(RegisterRequest data);
Task<RequestResult> Authenticate(AuthenticateRequest data);
Task<RequestResult> AuthenticateRefresh();
}

22
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Accounts/WatchIt.WebAPI.Services.Controllers.Accounts.csproj Normal file
View File

@@ -0,0 +1,22 @@
<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.Model\WatchIt.Database.Model\WatchIt.Database.Model.csproj" />
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\..\WatchIt.WebAPI.Services.Utility\WatchIt.WebAPI.Services.Utility.Tokens\WatchIt.WebAPI.Services.Utility.Tokens.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.5" />
</ItemGroup>
</Project>

44
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestBadRequestResult.cs Normal file
View File

@@ -0,0 +1,44 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestBadRequestResult : RequestResult
{
#region FIELDS
private readonly ModelStateDictionary _modelState;
#endregion
#region CONSTRUCTORS
public RequestBadRequestResult() : base(RequestResultStatus.BadRequest)
{
_modelState = new ModelStateDictionary();
}
#endregion
#region PUBLIC METHODS
public RequestBadRequestResult AddValidationError(string propertyName, string message)
{
_modelState.AddModelError(propertyName, message);
return this;
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new BadRequestObjectResult(_modelState);
#endregion
}

22
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestConflictResult.cs Normal file
View File

@@ -0,0 +1,22 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestConflictResult : RequestResult
{
#region CONSTRUCTORS
public RequestConflictResult() : base(RequestResultStatus.Conflict)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new ConflictResult();
#endregion
}

33
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestCreatedResult.cs Normal file
View File

@@ -0,0 +1,33 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestCreatedResult<T> : RequestResult
{
#region PROPERTIES
public string Location { get; }
public T Data { get; }
#endregion
#region CONSTRUCTORS
internal RequestCreatedResult(string location, T data) : base(RequestResultStatus.Created)
{
Location = location;
Data = data;
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new CreatedResult(Location, Data);
#endregion
}

22
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestForbiddenResult.cs Normal file
View File

@@ -0,0 +1,22 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestForbiddenResult : RequestResult
{
#region CONSTRUCTORS
public RequestForbiddenResult() : base(RequestResultStatus.Forbidden)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new ForbidResult();
#endregion
}

22
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestNoContentResult.cs Normal file
View File

@@ -0,0 +1,22 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestNoContentResult : RequestResult
{
#region CONSTRUCTORS
internal RequestNoContentResult() : base(RequestResultStatus.NoContent)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new NoContentResult();
#endregion
}

22
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestNotFoundResult.cs Normal file
View File

@@ -0,0 +1,22 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestNotFoundResult : RequestResult
{
#region CONSTRUCTORS
public RequestNotFoundResult() : base(RequestResultStatus.NotFound)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new NotFoundResult();
#endregion
}

47
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestOkResult.cs Normal file
View File

@@ -0,0 +1,47 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestOkResult : RequestResult
{
#region CONSTRUCTORS
internal RequestOkResult() : base(RequestResultStatus.Ok)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new OkResult();
#endregion
}
public class RequestOkResult<T> : RequestOkResult
{
#region PROPERTIES
public T Data { get; }
#endregion
#region CONSTRUCTORS
internal RequestOkResult(T data) : base() => Data = data;
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new OkObjectResult(Data);
#endregion
}

40
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestResult.cs Normal file
View File

@@ -0,0 +1,40 @@
using Microsoft.AspNetCore.Mvc;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public abstract class RequestResult
{
#region PROPERTIES
public RequestResultStatus Status { get; }
#endregion
#region CONSTRUCTORS
protected RequestResult(RequestResultStatus status) => Status = status;
public static RequestOkResult Ok() => new RequestOkResult();
public static RequestOkResult<T> Ok<T>(T data) => new RequestOkResult<T>(data);
public static RequestCreatedResult<T> Created<T>(string location, T data) => new RequestCreatedResult<T>(location, data);
public static RequestNoContentResult NoContent() => new RequestNoContentResult();
public static RequestBadRequestResult BadRequest() => new RequestBadRequestResult();
public static RequestUnauthorizedResult Unauthorized() => new RequestUnauthorizedResult();
public static RequestForbiddenResult Forbidden() => new RequestForbiddenResult();
public static RequestNotFoundResult NotFound() => new RequestNotFoundResult();
public static RequestConflictResult Conflict() => new RequestConflictResult();
#endregion
#region CONVERSION
public static implicit operator ActionResult(RequestResult result) => result.ConvertToActionResult();
protected abstract ActionResult ConvertToActionResult();
#endregion
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestResultStatus.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace WatchIt.WebAPI.Services.Controllers.Common;
public enum RequestResultStatus
{
Ok = 200,
Created = 201,
NoContent = 204,
BadRequest = 400,
Unauthorized = 401,
Forbidden = 403,
NotFound = 404,
Conflict = 409,
}

23
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/RequestUnauthorizedResult.cs Normal file
View File

@@ -0,0 +1,23 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
namespace WatchIt.WebAPI.Services.Controllers.Common;
public class RequestUnauthorizedResult : RequestResult
{
#region CONSTRUCTORS
public RequestUnauthorizedResult() : base(RequestResultStatus.Unauthorized)
{
}
#endregion
#region CONVERTION
protected override ActionResult ConvertToActionResult() => new UnauthorizedResult();
#endregion
}

19
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Common/WatchIt.WebAPI.Services.Controllers.Common.csproj Normal file
View File

@@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.AspNetCore.Mvc.Core">
<HintPath>..\..\..\..\..\..\..\..\Program Files\dotnet\shared\Microsoft.AspNetCore.App\8.0.2\Microsoft.AspNetCore.Mvc.Core.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
</ItemGroup>
</Project>

93
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Genres/GenresControllerService.cs Normal file
View File

@@ -0,0 +1,93 @@
using Microsoft.EntityFrameworkCore;
using WatchIt.Common.Model.Genres;
using WatchIt.Database;
using WatchIt.Database.Model.Media;
using WatchIt.WebAPI.Services.Controllers.Common;
using WatchIt.WebAPI.Services.Utility.User;
using Genre = WatchIt.Database.Model.Common.Genre;
namespace WatchIt.WebAPI.Services.Controllers.Genres;
public class GenresControllerService(DatabaseContext database, IUserService userService) : IGenresControllerService
{
#region PUBLIC METHODS
public async Task<RequestResult> GetAll(GenreQueryParameters query)
{
IEnumerable<GenreResponse> data = await database.Genres.Select(x => new GenreResponse(x)).ToListAsync();
data = query.PrepareData(data);
return RequestResult.Ok(data);
}
public async Task<RequestResult> Get(short id)
{
Genre? item = await database.Genres.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
GenreResponse data = new GenreResponse(item);
return RequestResult.Ok(data);
}
public async Task<RequestResult> Post(GenreRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
Genre item = data.CreateGenre();
await database.Genres.AddAsync(item);
await database.SaveChangesAsync();
return RequestResult.Created($"genres/{item.Id}", new GenreResponse(item));
}
public async Task<RequestResult> Put(short id, GenreRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
Genre? item = await database.Genres.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
data.UpdateGenre(item);
await database.SaveChangesAsync();
return RequestResult.Ok();
}
public async Task<RequestResult> Delete(short id)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
Genre? item = await database.Genres.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
database.MediaGenres.AttachRange(item.MediaGenres);
database.MediaGenres.RemoveRange(item.MediaGenres);
database.Genres.Attach(item);
database.Genres.Remove(item);
await database.SaveChangesAsync();
return RequestResult.Ok();
}
#endregion
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Genres/IGenresControllerService.cs Normal file
View File

@@ -0,0 +1,13 @@
using WatchIt.Common.Model.Genres;
using WatchIt.WebAPI.Services.Controllers.Common;
namespace WatchIt.WebAPI.Services.Controllers.Genres;
public interface IGenresControllerService
{
Task<RequestResult> GetAll(GenreQueryParameters query);
Task<RequestResult> Get(short id);
Task<RequestResult> Post(GenreRequest data);
Task<RequestResult> Put(short id, GenreRequest data);
Task<RequestResult> Delete(short id);
}

16
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Genres/WatchIt.WebAPI.Services.Controllers.Genres.csproj Normal file
View File

@@ -0,0 +1,16 @@
<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>
</Project>

16
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Movies/IMoviesControllerService.cs Normal file
View File

@@ -0,0 +1,16 @@
using WatchIt.Common.Model.Movies;
using WatchIt.WebAPI.Services.Controllers.Common;
namespace WatchIt.WebAPI.Services.Controllers.Movies;
public interface IMoviesControllerService
{
Task<RequestResult> GetAll(MovieQueryParameters query);
Task<RequestResult> Get(long id);
Task<RequestResult> Post(MovieRequest data);
Task<RequestResult> Put(long id, MovieRequest data);
Task<RequestResult> Delete(long id);
Task<RequestResult> GetGenres(long movieId);
Task<RequestResult> PostGenre(long movieId, short genreId);
Task<RequestResult> DeleteGenre(long movieId, short genreId);
}

171
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Movies/MoviesControllerService.cs Normal file
View File

@@ -0,0 +1,171 @@
using Microsoft.EntityFrameworkCore;
using WatchIt.Common.Model.Genres;
using WatchIt.Common.Model.Movies;
using WatchIt.Database;
using WatchIt.Database.Model.Media;
using WatchIt.WebAPI.Services.Controllers.Common;
using WatchIt.WebAPI.Services.Utility.User;
using Genre = WatchIt.Database.Model.Common.Genre;
namespace WatchIt.WebAPI.Services.Controllers.Movies;
public class MoviesControllerService(DatabaseContext database, IUserService userService) : IMoviesControllerService
{
#region PUBLIC METHODS
public async Task<RequestResult> GetAll(MovieQueryParameters query)
{
IEnumerable<MovieResponse> data = await database.MediaMovies.Select(x => new MovieResponse(x)).ToListAsync();
data = query.PrepareData(data);
return RequestResult.Ok(data);
}
public async Task<RequestResult> Get(long id)
{
MediaMovie? item = await database.MediaMovies.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
MovieResponse data = new MovieResponse(item);
return RequestResult.Ok(data);
}
public async Task<RequestResult> Post(MovieRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
Media mediaItem = data.CreateMedia();
await database.Media.AddAsync(mediaItem);
await database.SaveChangesAsync();
MediaMovie mediaMovieItem = data.CreateMediaMovie(mediaItem.Id);
await database.MediaMovies.AddAsync(mediaMovieItem);
await database.SaveChangesAsync();
return RequestResult.Created($"movies/{mediaItem.Id}", new MovieResponse(mediaMovieItem));
}
public async Task<RequestResult> Put(long id, MovieRequest data)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaMovie? item = await database.MediaMovies.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
data.UpdateMediaMovie(item);
data.UpdateMedia(item.Media);
await database.SaveChangesAsync();
return RequestResult.Ok();
}
public async Task<RequestResult> Delete(long id)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaMovie? item = await database.MediaMovies.FirstOrDefaultAsync(x => x.Id == id);
if (item is null)
{
return RequestResult.NotFound();
}
database.MediaMovies.Attach(item);
database.MediaMovies.Remove(item);
database.MediaPosterImages.Attach(item.Media.MediaPosterImage!);
database.MediaPosterImages.Remove(item.Media.MediaPosterImage!);
database.MediaPhotoImages.AttachRange(item.Media.MediaPhotoImages);
database.MediaPhotoImages.RemoveRange(item.Media.MediaPhotoImages);
database.MediaGenres.AttachRange(item.Media.MediaGenres);
database.MediaGenres.RemoveRange(item.Media.MediaGenres);
database.MediaProductionCountries.AttachRange(item.Media.MediaProductionCountries);
database.MediaProductionCountries.RemoveRange(item.Media.MediaProductionCountries);
database.PersonActorRoles.AttachRange(item.Media.PersonActorRoles);
database.PersonActorRoles.RemoveRange(item.Media.PersonActorRoles);
database.PersonCreatorRoles.AttachRange(item.Media.PersonCreatorRoles);
database.PersonCreatorRoles.RemoveRange(item.Media.PersonCreatorRoles);
database.RatingsMedia.AttachRange(item.Media.RatingMedia);
database.RatingsMedia.RemoveRange(item.Media.RatingMedia);
database.ViewCountsMedia.AttachRange(item.Media.ViewCountsMedia);
database.ViewCountsMedia.RemoveRange(item.Media.ViewCountsMedia);
database.Media.Attach(item.Media);
database.Media.Remove(item.Media);
await database.SaveChangesAsync();
return RequestResult.Ok();
}
public async Task<RequestResult> GetGenres(long movieId)
{
MediaMovie? item = await database.MediaMovies.FirstOrDefaultAsync(x => x.Id == movieId);
if (item is null)
{
return RequestResult.NotFound();
}
IEnumerable<GenreResponse> genres = item.Media.MediaGenres.Select(x => new GenreResponse(x.Genre));
return RequestResult.Ok(genres);
}
public async Task<RequestResult> PostGenre(long movieId, short genreId)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaMovie? movieItem = await database.MediaMovies.FirstOrDefaultAsync(x => x.Id == movieId);
Genre? genreItem = await database.Genres.FirstOrDefaultAsync(x => x.Id == genreId);
if (movieItem is null || genreItem is null)
{
return RequestResult.NotFound();
}
await database.MediaGenres.AddAsync(new MediaGenre
{
GenreId = genreId,
MediaId = movieId,
});
return RequestResult.Ok();
}
public async Task<RequestResult> DeleteGenre(long movieId, short genreId)
{
UserValidator validator = userService.GetValidator().MustBeAdmin();
if (!validator.IsValid)
{
return RequestResult.Forbidden();
}
MediaGenre? item = await database.MediaGenres.FirstOrDefaultAsync(x => x.MediaId == movieId && x.GenreId == genreId);
if (item is null)
{
return RequestResult.NotFound();
}
database.MediaGenres.Attach(item);
database.MediaGenres.Remove(item);
await database.SaveChangesAsync();
return RequestResult.Ok();
}
#endregion
}

16
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.Movies/WatchIt.WebAPI.Services.Controllers.Movies.csproj Normal file
View File

@@ -0,0 +1,16 @@
<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>
</Project>

20
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Controllers/WatchIt.WebAPI.Services.Controllers.csproj
View File

@@ -1,20 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.3" />
<PackageReference Include="SimpleToolkit.Extensions" Version="1.7.5" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\..\..\WatchIt.Shared\WatchIt.Shared.Models\WatchIt.Shared.Models.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services.Utility\WatchIt.WebAPI.Services.Utility.JWT\WatchIt.WebAPI.Services.Utility.JWT.csproj" />
</ItemGroup>
</Project>

29
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/ConfigurationService.cs
View File

@@ -1,26 +1,13 @@
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WatchIt.WebAPI.Services.Utility.Configuration.Models;
using WatchIt.WebAPI.Services.Utility.Configuration.Model;
namespace WatchIt.WebAPI.Services.Utility.Configuration
namespace WatchIt.WebAPI.Services.Utility.Configuration;
public class ConfigurationService(IConfiguration configuration) : IConfigurationService
{
public interface IConfigurationService
{
ConfigurationData Data { get; }
}
#region PROPERTIES
public ConfigurationData Data => configuration.Get<ConfigurationData>()!;
public class ConfigurationService(IConfiguration configuration) : IConfigurationService
{
#region PROPERTIES
public ConfigurationData Data => configuration.GetSection("WebAPI").Get<ConfigurationData>()!;
#endregion
}
}
#endregion
}

8
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/IConfigurationService.cs Normal file
View File

@@ -0,0 +1,8 @@
using WatchIt.WebAPI.Services.Utility.Configuration.Model;
namespace WatchIt.WebAPI.Services.Utility.Configuration;
public interface IConfigurationService
{
ConfigurationData Data { get; }
}

8
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/Authentication.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class Authentication
{
public string Key { get; set; }
public string Issuer { get; set; }
public Tokens Tokens { get; set; }
}

10
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/ConfigurationData.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class ConfigurationData
{
public Logging Logging { get; set; }
public string AllowedHosts { get; set; }
public ConnectionStrings ConnectionStrings { get; set; }
public RootUser RootUser { get; set; }
public Authentication Authentication { get; set; }
}

6
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/ConnectionStrings.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class ConnectionStrings
{
public string Default { get; set; }
}

6
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/Console.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class Console
{
public FormatterOptions FormatterOptions { get; set; }
}

6
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/FormatterOptions.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class FormatterOptions
{
public string TimestampFormat { get; set; }
}

8
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/LogLevel.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class LogLevel
{
public string Default { get; set; }
public string Microsoft_AspNetCore { get; set; }
public string Microsoft_EntityFrameworkCore_Database_Command { get; set; }
}

7
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/Logging.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class Logging
{
public LogLevel LogLevel { get; set; }
public Console Console { get; set; }
}

8
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/RootUser.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class RootUser
{
public string Username { get; set; }
public string Email { get; set; }
public string Password { get; set; }
}

7
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/Token.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class Token
{
public int NormalLifetime { get; set; }
public int ExtendedLifetime { get; set; }
}

7
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Model/Tokens.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace WatchIt.WebAPI.Services.Utility.Configuration.Model;
public class Tokens
{
public Token RefreshToken { get; set; }
public Token AccessToken { get; set; }
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Models/AccessToken.cs
View File

@@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.Configuration.Models
{
public class AccessToken
{
public int Lifetime { get; set; }
}
}

16
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Models/Authentication.cs
View File

@@ -1,16 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.Configuration.Models
{
public class Authentication
{
public string Key { get; set; }
public string Issuer { get; set; }
public RefreshToken RefreshToken { get; set; }
public AccessToken AccessToken { get; set; }
}
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Models/ConfigurationData.cs
View File

@@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.Configuration.Models
{
public class ConfigurationData
{
public Authentication Authentication { get; set; }
}
}

14
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/Models/RefreshToken.cs
View File

@@ -1,14 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.Configuration.Models
{
public class RefreshToken
{
public int Lifetime { get; set; }
public int ExtendedLifetime { get; set; }
}
}

17
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Configuration/WatchIt.WebAPI.Services.Utility.Configuration.csproj
View File

@@ -1,13 +1,14 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.3" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.1" />
</ItemGroup>
</Project>

131
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.JWT/JWTService.cs
View File

@@ -1,131 +0,0 @@
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Security.Principal;
using System.Text;
using System.Threading.Tasks;
using WatchIt.Database;
using WatchIt.Database.Model.Account;
using WatchIt.WebAPI.Services.Utility.Configuration;
namespace WatchIt.WebAPI.Services.Utility.JWT
{
public interface IJWTService
{
Task<string> CreateAccessToken(Account account);
Task<string> CreateRefreshToken(Account account, bool extendable);
Task<string> ExtendRefreshToken(Account account, Guid id);
}
public class JWTService(IConfigurationService configurationService, DatabaseContext database) : IJWTService
{
#region PUBLIC METHODS
public async Task<string> CreateRefreshToken(Account account, bool extendable)
{
int expirationMinutes = extendable ? configurationService.Data.Authentication.RefreshToken.ExtendedLifetime : configurationService.Data.Authentication.RefreshToken.Lifetime;
DateTime expirationDate = DateTime.UtcNow.AddMinutes(expirationMinutes);
Guid id = Guid.NewGuid();
AccountRefreshToken refreshToken = new AccountRefreshToken
{
Id = id,
AccountId = account.Id,
ExpirationDate = expirationDate,
IsExtendable = extendable
};
database.AccountRefreshTokens.Add(refreshToken);
Task saveTask = database.SaveChangesAsync();
SecurityTokenDescriptor tokenDescriptor = CreateBaseSecurityTokenDescriptor(account, id, expirationDate);
tokenDescriptor.Audience = "refresh";
tokenDescriptor.Subject.AddClaim(new Claim("extend", extendable.ToString()));
string tokenString = TokenToString(tokenDescriptor);
await saveTask;
return tokenString;
}
public async Task<string> ExtendRefreshToken(Account account, Guid id)
{
AccountRefreshToken? token = account.AccountRefreshTokens.FirstOrDefault(x => x.Id == id);
if (token is null)
{
throw new TokenNotFoundException();
}
if (!token.IsExtendable)
{
throw new TokenNotExtendableException();
}
int expirationMinutes = configurationService.Data.Authentication.RefreshToken.ExtendedLifetime;
DateTime expirationDate = DateTime.UtcNow.AddMinutes(expirationMinutes);
token.ExpirationDate = expirationDate;
Task saveTask = database.SaveChangesAsync();
SecurityTokenDescriptor tokenDescriptor = CreateBaseSecurityTokenDescriptor(account, id, expirationDate);
tokenDescriptor.Audience = "refresh";
tokenDescriptor.Subject.AddClaim(new Claim("extend", bool.TrueString));
string tokenString = TokenToString(tokenDescriptor);
await saveTask;
return tokenString;
}
public async Task<string> CreateAccessToken(Account account)
{
DateTime lifetime = DateTime.Now.AddMinutes(configurationService.Data.Authentication.AccessToken.Lifetime);
Guid id = Guid.NewGuid();
SecurityTokenDescriptor tokenDescriptor = CreateBaseSecurityTokenDescriptor(account, id, lifetime);
tokenDescriptor.Audience = "access";
tokenDescriptor.Subject.AddClaim(new Claim("admin", account.IsAdmin.ToString()));
return TokenToString(tokenDescriptor);
}
#endregion
#region PRIVATE METHODS
protected SecurityTokenDescriptor CreateBaseSecurityTokenDescriptor(Account account, Guid id, DateTime expirationTime) => new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new List<Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, id.ToString()),
new Claim(JwtRegisteredClaimNames.Sub, account.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Email, account.Email),
new Claim(JwtRegisteredClaimNames.UniqueName, account.Username),
new Claim(JwtRegisteredClaimNames.Exp, expirationTime.ToString()),
}),
Expires = expirationTime,
Issuer = configurationService.Data.Authentication.Issuer,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configurationService.Data.Authentication.Key)), SecurityAlgorithms.HmacSha512)
};
protected string TokenToString(SecurityTokenDescriptor tokenDescriptor)
{
System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler handler = new System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler();
handler.InboundClaimTypeMap.Clear();
SecurityToken token = handler.CreateToken(tokenDescriptor);
return handler.WriteToken(token);
}
#endregion
}
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.JWT/TokenNotExtendableException.cs
View File

@@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.JWT
{
public class TokenNotExtendableException : Exception
{
public TokenNotExtendableException() : base() { }
}
}

13
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.JWT/TokenNotFoundException.cs
View File

@@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Services.Utility.JWT
{
public class TokenNotFoundException : Exception
{
public TokenNotFoundException() : base() { }
}
}

21
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.JWT/WatchIt.WebAPI.Services.Utility.JWT.csproj
View File

@@ -1,21 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.IdentityModel.JsonWebTokens" Version="7.1.2" />
<PackageReference Include="Microsoft.IdentityModel.Tokens" Version="7.1.2" />
<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.1.2" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database.Model\WatchIt.Database.Model.csproj" />
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services.Utility.Configuration\WatchIt.WebAPI.Services.Utility.Configuration.csproj" />
</ItemGroup>
</Project>

6
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Tokens/Exceptions/TokenNotExtendableException.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace WatchIt.WebAPI.Services.Utility.Tokens.Exceptions;
public class TokenNotExtendableException : Exception
{
public TokenNotExtendableException() : base() { }
}

6
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Tokens/Exceptions/TokenNotFoundException.cs Normal file
View File

@@ -0,0 +1,6 @@
namespace WatchIt.WebAPI.Services.Utility.Tokens.Exceptions;
public class TokenNotFoundException : Exception
{
public TokenNotFoundException() : base() { }
}

11
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Tokens/ITokensService.cs Normal file
View File

@@ -0,0 +1,11 @@
using WatchIt.Database.Model.Account;
namespace WatchIt.WebAPI.Services.Utility.Tokens;
public interface ITokensService
{
Task<string> CreateRefreshTokenAsync(Account account, bool extendable);
Task<string> ExtendRefreshTokenAsync(Account account, Guid id);
Task<string> CreateAccessTokenAsync(Account account);
string CreateAccessToken(Account account);
}

115
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Tokens/TokensService.cs Normal file
View File

@@ -0,0 +1,115 @@
using System.Globalization;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.IdentityModel.Tokens;
using WatchIt.Database;
using WatchIt.Database.Model.Account;
using WatchIt.WebAPI.Services.Utility.Configuration;
using WatchIt.WebAPI.Services.Utility.Tokens.Exceptions;
namespace WatchIt.WebAPI.Services.Utility.Tokens;
public class TokensService(DatabaseContext database, IConfigurationService configurationService) : ITokensService
{
#region FIELDS
private readonly Configuration.Model.Tokens _tokensConfig = configurationService.Data.Authentication.Tokens;
#endregion
#region PUBLIC METHODS
public async Task<string> CreateRefreshTokenAsync(Account account, bool extendable)
{
int expirationMinutes = extendable ? _tokensConfig.RefreshToken.ExtendedLifetime : _tokensConfig.RefreshToken.NormalLifetime;
DateTime expirationDate = DateTime.UtcNow.AddMinutes(expirationMinutes);
Guid id = Guid.NewGuid();
database.AccountRefreshTokens.Add(new AccountRefreshToken
{
Id = id,
AccountId = account.Id,
ExpirationDate = expirationDate,
IsExtendable = extendable,
});
await database.SaveChangesAsync();
return GenerateRefreshJwt(account, id, expirationDate, extendable);
}
public async Task<string> ExtendRefreshTokenAsync(Account account, Guid id)
{
AccountRefreshToken? token = account.AccountRefreshTokens.FirstOrDefault(x => x.Id == id);
switch (token)
{
case null: throw new TokenNotFoundException();
case { IsExtendable: true }: throw new TokenNotExtendableException();
}
DateTime expirationDate = DateTime.UtcNow.AddMinutes(_tokensConfig.RefreshToken.ExtendedLifetime);
token.ExpirationDate = expirationDate;
await database.SaveChangesAsync();
return GenerateRefreshJwt(account, id, expirationDate, true);
}
public async Task<string> CreateAccessTokenAsync(Account account) => await Task.Run(() => CreateAccessToken(account));
public string CreateAccessToken(Account account)
{
DateTime lifetime = DateTime.Now.AddMinutes(_tokensConfig.AccessToken.NormalLifetime);
Guid id = Guid.NewGuid();
SecurityTokenDescriptor tokenDescriptor = CreateBaseSecurityTokenDescriptor(account, id, lifetime);
tokenDescriptor.Audience = "access";
return TokenToString(tokenDescriptor);
}
#endregion
#region PRIVATE METHODS
protected string GenerateRefreshJwt(Account account, Guid id, DateTime expirationDate, bool extendable)
{
SecurityTokenDescriptor tokenDescriptor = CreateBaseSecurityTokenDescriptor(account, id, expirationDate);
tokenDescriptor.Audience = "refresh";
tokenDescriptor.Subject.AddClaim(new Claim("extend", extendable.ToString()));
return TokenToString(tokenDescriptor);
}
protected SecurityTokenDescriptor CreateBaseSecurityTokenDescriptor(Account account, Guid id, DateTime expirationTime) => new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new List<Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, id.ToString()),
new Claim(JwtRegisteredClaimNames.Sub, account.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Email, account.Email),
new Claim(JwtRegisteredClaimNames.UniqueName, account.Username),
new Claim(JwtRegisteredClaimNames.Exp, expirationTime.Ticks.ToString()),
new Claim("admin", account.IsAdmin.ToString()),
}),
Expires = expirationTime,
Issuer = configurationService.Data.Authentication.Issuer,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configurationService.Data.Authentication.Key)), SecurityAlgorithms.HmacSha512)
};
protected string TokenToString(SecurityTokenDescriptor tokenDescriptor)
{
JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();
handler.InboundClaimTypeMap.Clear();
SecurityToken token = handler.CreateToken(tokenDescriptor);
return handler.WriteToken(token);
}
#endregion
}

19
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.Tokens/WatchIt.WebAPI.Services.Utility.Tokens.csproj Normal file
View File

@@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database.Model\WatchIt.Database.Model\WatchIt.Database.Model.csproj" />
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services.Utility.Configuration\WatchIt.WebAPI.Services.Utility.Configuration.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
</ItemGroup>
</Project>

46
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.User/UserService.cs
View File

@@ -1,18 +1,36 @@
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using Microsoft.AspNetCore.Http;
using WatchIt.Database;
namespace WatchIt.WebAPI.Services.Utility.User
namespace WatchIt.WebAPI.Services.Utility.User;
public class UserService(DatabaseContext database, IHttpContextAccessor accessor) : IUserService
{
public class UserService(IHttpContextAccessor accessor)
#region PUBLIC METHODS
public ClaimsPrincipal GetRawUser()
{
#region PUBLIC METHODS
#endregion
if (accessor.HttpContext is null)
{
throw new NullReferenceException();
}
return accessor.HttpContext.User;
}
}
public UserValidator GetValidator()
{
ClaimsPrincipal rawUser = GetRawUser();
return new UserValidator(database, rawUser);
}
public Guid GetJti()
{
ClaimsPrincipal user = GetRawUser();
Claim jtiClaim = user.FindFirst(JwtRegisteredClaimNames.Jti)!;
Guid guid = Guid.Parse(jtiClaim.Value);
return guid;
}
#endregion
}

21
WatchIt.WebAPI/WatchIt.WebAPI.Services/WatchIt.WebAPI.Services.Utility/WatchIt.WebAPI.Services.Utility.User/WatchIt.WebAPI.Services.Utility.User.csproj
View File

@@ -1,13 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.2.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.1" />
</ItemGroup>
</Project>

29
WatchIt.WebAPI/WatchIt.WebAPI.Validators/Accounts/AuthenticateRequestValidator.cs
View File

@@ -1,26 +1,13 @@
using FluentValidation;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using WatchIt.Database;
using WatchIt.Shared.Models.Accounts.Authenticate;
using WatchIt.Common.Model.Accounts;
namespace WatchIt.WebAPI.Validators.Accounts
namespace WatchIt.WebAPI.Validators.Accounts;
public class AuthenticateRequestValidator : AbstractValidator<AuthenticateRequest>
{
public class AuthenticateRequestValidator : AbstractValidator<AuthenticateRequest>
public AuthenticateRequestValidator()
{
#region CONSTRUCTOR
public AuthenticateRequestValidator(DatabaseContext database)
{
RuleFor(x => x.UsernameOrEmail).NotEmpty();
RuleFor(x => x.Password).NotEmpty();
}
#endregion
RuleFor(x => x.UsernameOrEmail).NotEmpty();
RuleFor(x => x.Password).NotEmpty();
}
}
}

40
WatchIt.WebAPI/WatchIt.WebAPI.Validators/Accounts/RegisterRequestValidator.cs
View File

@@ -1,31 +1,21 @@
using FluentValidation;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WatchIt.Common.Model.Accounts;
using WatchIt.Database;
using WatchIt.Shared.Models.Accounts.Register;
namespace WatchIt.WebAPI.Validators.Accounts
namespace WatchIt.WebAPI.Validators.Accounts;
public class RegisterRequestValidator : AbstractValidator<RegisterRequest>
{
public class RegisterRequestValidator : AbstractValidator<RegisterRequest>
public RegisterRequestValidator(DatabaseContext database)
{
#region CONSTRUCTOR
public RegisterRequestValidator(DatabaseContext database)
{
RuleFor(x => x.Username).MinimumLength(5)
.MaximumLength(50)
.CannotBeIn(database.Accounts, x => x.Username).WithMessage("Username was already used");
RuleFor(x => x.Email).EmailAddress()
.CannotBeIn(database.Accounts, x => x.Email).WithMessage("Email was already used");
RuleFor(x => x.Password).MinimumLength(8)
.Must(x => x.Any(c => Char.IsUpper(c))).WithMessage("Password must contain at least one uppercase letter.")
.Must(x => x.Any(c => Char.IsLower(c))).WithMessage("Password must contain at least one lowercase letter.")
.Must(x => x.Any(c => Char.IsDigit(c))).WithMessage("Password must contain at least one digit.");
}
#endregion
RuleFor(x => x.Username).MinimumLength(5)
.MaximumLength(50)
.CannotBeIn(database.Accounts, x => x.Username).WithMessage("Username was already used");
RuleFor(x => x.Email).EmailAddress()
.CannotBeIn(database.Accounts, x => x.Email).WithMessage("Email was already used");
RuleFor(x => x.Password).MinimumLength(8)
.Must(x => x.Any(char.IsUpper)).WithMessage("Password must contain at least one uppercase letter.")
.Must(x => x.Any(char.IsLower)).WithMessage("Password must contain at least one lowercase letter.")
.Must(x => x.Any(char.IsDigit)).WithMessage("Password must contain at least one digit.");
}
}
}

23
WatchIt.WebAPI/WatchIt.WebAPI.Validators/CustomValidators.cs
View File

@@ -1,18 +1,11 @@
using FluentValidation;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WatchIt.WebAPI.Validators
namespace WatchIt.WebAPI.Validators;
public static class CustomValidators
{
public static class CustomValidators
{
public static IRuleBuilderOptions<T, TProperty> CannotBeIn<T, TProperty>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TProperty> collection) => ruleBuilder.Must(x => !collection.Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> CannotBeIn<T, TProperty, TCollectionType>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TCollectionType> collection, Func<TCollectionType, TProperty> propertyFunc) => ruleBuilder.Must(x => !collection.Select(propertyFunc).Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> MustBeIn<T, TProperty>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TProperty> collection) => ruleBuilder.Must(x => collection.Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> MustBeIn<T, TProperty, TCollectionType>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TCollectionType> collection, Func<TCollectionType, TProperty> propertyFunc) => ruleBuilder.Must(x => collection.Select(propertyFunc).Any(e => Equals(e, x)));
}
}
public static IRuleBuilderOptions<T, TProperty> CannotBeIn<T, TProperty>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TProperty> collection) => ruleBuilder.Must(x => !collection.Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> CannotBeIn<T, TProperty, TCollectionType>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TCollectionType> collection, Func<TCollectionType, TProperty> propertyFunc) => ruleBuilder.Must(x => !collection.Select(propertyFunc).Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> MustBeIn<T, TProperty>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TProperty> collection) => ruleBuilder.Must(x => collection.Any(e => Equals(e, x)));
public static IRuleBuilderOptions<T, TProperty> MustBeIn<T, TProperty, TCollectionType>(this IRuleBuilder<T, TProperty> ruleBuilder, IEnumerable<TCollectionType> collection, Func<TCollectionType, TProperty> propertyFunc) => ruleBuilder.Must(x => collection.Select(propertyFunc).Any(e => Equals(e, x)));
}

14
WatchIt.WebAPI/WatchIt.WebAPI.Validators/Genres/GenreRequestValidator.cs Normal file
View File

@@ -0,0 +1,14 @@
using FluentValidation;
using WatchIt.Common.Model.Genres;
using WatchIt.Database;
namespace WatchIt.WebAPI.Validators.Genres;
public class GenreRequestValidator : AbstractValidator<GenreRequest>
{
public GenreRequestValidator()
{
RuleFor(x => x.Name).MaximumLength(100);
When(x => !string.IsNullOrWhiteSpace(x.Description), () => RuleFor(x => x.Description).MaximumLength(1000));
}
}

26
WatchIt.WebAPI/WatchIt.WebAPI.Validators/WatchIt.WebAPI.Validators.csproj
View File

@@ -1,19 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="FluentValidation" Version="11.9.0" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.3" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WatchIt.Common\WatchIt.Common.Model\WatchIt.Common.Model.csproj" />
<ProjectReference Include="..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\..\WatchIt.Shared\WatchIt.Shared.Models\WatchIt.Shared.Models.csproj" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="FluentValidation" Version="11.9.0" />
<PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.9.0" />
</ItemGroup>
</Project>

30
WatchIt.WebAPI/WatchIt.WebAPI.WorkerServices/DeleteExpiredRefreshTokensService.cs Normal file
View File

@@ -0,0 +1,30 @@
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using WatchIt.Database;
using WatchIt.Database.Model.Account;
namespace WatchIt.WebAPI.WorkerServices;
public class DeleteExpiredRefreshTokensService(ILogger<DeleteExpiredRefreshTokensService> logger, DatabaseContext database) : BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
Task delayTask = Task.Delay(300000, stoppingToken);
Task actionTask = Action();
await Task.WhenAll(delayTask, actionTask);
}
}
protected async Task Action()
{
IEnumerable<AccountRefreshToken> tokens = database.AccountRefreshTokens.Where(x => x.ExpirationDate < DateTime.UtcNow);
database.AccountRefreshTokens.AttachRange(tokens);
database.AccountRefreshTokens.RemoveRange(tokens);
await database.SaveChangesAsync();
}
}

17
WatchIt.WebAPI/WatchIt.WebAPI.WorkerServices/WatchIt.WebAPI.WorkerServices.csproj Normal file
View File

@@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
</ItemGroup>
</Project>

23
WatchIt.WebAPI/WatchIt.WebAPI/Dockerfile Normal file
View File

@@ -0,0 +1,23 @@
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
USER $APP_UID
WORKDIR /app
EXPOSE 8080
EXPOSE 8081
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["WatchIt.WebAPI/WatchIt.WebAPI/WatchIt.WebAPI.csproj", "WatchIt.WebAPI/WatchIt.WebAPI/"]
RUN dotnet restore "WatchIt.WebAPI/WatchIt.WebAPI/WatchIt.WebAPI.csproj"
COPY . .
WORKDIR "/src/WatchIt.WebAPI/WatchIt.WebAPI"
RUN dotnet build "WatchIt.WebAPI.csproj" -c $BUILD_CONFIGURATION -o /app/build
FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "WatchIt.WebAPI.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "WatchIt.WebAPI.dll"]

161
WatchIt.WebAPI/WatchIt.WebAPI/Program.cs Normal file
View File

@@ -0,0 +1,161 @@
using System.Reflection;
using System.Text;
using FluentValidation;
using FluentValidation.AspNetCore;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using WatchIt.Database;
using WatchIt.WebAPI.Services.Controllers.Accounts;
using WatchIt.WebAPI.Services.Controllers.Genres;
using WatchIt.WebAPI.Services.Controllers.Movies;
using WatchIt.WebAPI.Services.Utility.Configuration;
using WatchIt.WebAPI.Services.Utility.Tokens;
using WatchIt.WebAPI.Services.Utility.User;
using WatchIt.WebAPI.Validators;
using WatchIt.WebAPI.WorkerServices;
namespace WatchIt.WebAPI;
public static class Program
{
#region PUBLIC METHODS
public static void Main(string[] args)
{
WebApplication app = WebApplication.CreateBuilder(args)
.SetupAuthentication()
.SetupDatabase()
.SetupWorkerServices()
.SetupServices()
.SetupApplication()
.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
}
#endregion
#region PRIVATE METHODS
private static WebApplicationBuilder SetupAuthentication(this WebApplicationBuilder builder)
{
AuthenticationBuilder authenticationBuilder = builder.Services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
});
authenticationBuilder.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration.GetValue<string>("Authentication:Key")!)),
ValidateAudience = true,
ValidAudience = "access",
ValidIssuer = builder.Configuration.GetValue<string>("Authentication:Issuer"),
ValidateLifetime = true,
ClockSkew = TimeSpan.FromMinutes(1),
};
x.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
context.Response.Headers.Append("Token-Expired", "true");
}
return Task.CompletedTask;
},
};
});
authenticationBuilder.AddJwtBearer("refresh", x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration.GetValue<string>("Authentication:Key")!)),
ValidateAudience = true,
ValidIssuer = builder.Configuration.GetValue<string>("Authentication:Issuer"),
ValidAudience = "refresh",
ValidateLifetime = true,
ClockSkew = TimeSpan.FromMinutes(1)
};
x.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
context.Response.Headers.Append("Token-Expired", "true");
}
return Task.CompletedTask;
}
};
});
builder.Services.AddAuthorization();
return builder;
}
private static WebApplicationBuilder SetupDatabase(this WebApplicationBuilder builder)
{
builder.Services.AddDbContext<DatabaseContext>(x => x.UseLazyLoadingProxies().UseNpgsql(builder.Configuration.GetConnectionString("Default")), ServiceLifetime.Singleton);
return builder;
}
private static WebApplicationBuilder SetupWorkerServices(this WebApplicationBuilder builder)
{
builder.Services.AddHostedService<DeleteExpiredRefreshTokensService>();
return builder;
}
private static WebApplicationBuilder SetupServices(this WebApplicationBuilder builder)
{
// Utility
builder.Services.AddSingleton<IConfigurationService, ConfigurationService>();
builder.Services.AddSingleton<ITokensService, TokensService>();
builder.Services.AddSingleton<IUserService, UserService>();
// Controller
builder.Services.AddSingleton<IAccountsControllerService, AccountsControllerService>();
builder.Services.AddSingleton<IGenresControllerService, GenresControllerService>();
builder.Services.AddSingleton<IMoviesControllerService, MoviesControllerService>();
return builder;
}
private static WebApplicationBuilder SetupApplication(this WebApplicationBuilder builder)
{
builder.Services.AddValidatorsFromAssembly(Assembly.GetAssembly(typeof(CustomValidators)));
builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddHttpContextAccessor();
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
return builder;
}
#endregion
}

41
WatchIt.WebAPI/WatchIt.WebAPI/Properties/launchSettings.json Normal file
View File

@@ -0,0 +1,41 @@
{
"$schema": "http://json.schemastore.org/launchsettings.json",
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:10207",
"sslPort": 44335
}
},
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "swagger",
"applicationUrl": "http://localhost:5179",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"https": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "swagger",
"applicationUrl": "https://localhost:7160;http://localhost:5179",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
},
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"launchUrl": "swagger",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}

36
WatchIt.WebAPI/WatchIt.WebAPI/WatchIt.WebAPI.csproj Normal file
View File

@@ -0,0 +1,36 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="FluentValidation.AspNetCore" Version="11.3.0" />
<PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.9.0" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.4" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.4">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
</ItemGroup>
<ItemGroup>
<Content Include="..\..\.dockerignore">
<Link>.dockerignore</Link>
</Content>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\WatchIt.Database\WatchIt.Database\WatchIt.Database.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Controllers\WatchIt.WebAPI.Controllers.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Utility\WatchIt.WebAPI.Services.Utility.Configuration\WatchIt.WebAPI.Services.Utility.Configuration.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Services\WatchIt.WebAPI.Services.Utility\WatchIt.WebAPI.Services.Utility.Tokens\WatchIt.WebAPI.Services.Utility.Tokens.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.Validators\WatchIt.WebAPI.Validators.csproj" />
<ProjectReference Include="..\WatchIt.WebAPI.WorkerServices\WatchIt.WebAPI.WorkerServices.csproj" />
</ItemGroup>
</Project>

36
WatchIt.WebAPI/WatchIt.WebAPI/appsettings.json Normal file
View File

@@ -0,0 +1,36 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning",
"Microsoft.EntityFrameworkCore.Database.Command": "Warning"
},
"Console": {
"FormatterOptions": {
"TimestampFormat": "[yyyy-MM-dd HH:mm:ss] "
}
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"Default": "Host=localhost;Database=watchit;Username=watchit;Password=Xdv2Etchavbuuho"
},
"RootUser": {
"Username": "root",
"Email": "root@watch.it",
"Password": "bECdHfbus2QHr4QQjApM"
},
"Authentication": {
"Key": "testkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytestkeytest",
"Issuer": "WatchIt",
"Tokens": {
"RefreshToken": {
"NormalLifetime": 1440,
"ExtendedLifetime": 10080
},
"AccessToken": {
"NormalLifetime": 5
}
}
}
}