Добавьте файлы проекта.

2026-04-13 14:16:44 +03:00
parent b2b5a3945a
commit 37c997dbe0
120 changed files with 5364 additions and 0 deletions
--- a/PlaylistShared.Api/Services/JwtService.cs
+++ b/PlaylistShared.Api/Services/JwtService.cs
@@ -0,0 +1,49 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.IdentityModel.Tokens;
+using PlaylistShared.Api.Entities;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+namespace PlaylistShared.Api.Services;
+
+public class JwtService
+{
+    private readonly IConfiguration _configuration;
+    private readonly UserManager<ApplicationUser> _userManager;
+
+    public JwtService(IConfiguration configuration, UserManager<ApplicationUser> userManager)
+    {
+        _configuration = configuration;
+        _userManager = userManager;
+    }
+
+    public async Task<(string Token, string RefreshToken, DateTime Expiration)> GenerateTokenAsync(ApplicationUser user)
+    {
+        var tokenHandler = new JwtSecurityTokenHandler();
+
+        var key = Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]!);
+        var tokenDescriptor = new SecurityTokenDescriptor
+        {
+            Subject = new ClaimsIdentity(new[]
+            {
+                new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
+                new Claim(ClaimTypes.Name, user.UserName!),
+                new Claim(ClaimTypes.Email, user.Email!),
+            }),
+            Expires = DateTime.UtcNow.AddHours(1),
+            Issuer = _configuration["Jwt:Issuer"],
+            Audience = _configuration["Jwt:Audience"],
+            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
+        };
+        var token = tokenHandler.CreateToken(tokenDescriptor);
+        var tokenString = tokenHandler.WriteToken(token);
+
+        var refreshToken = Guid.NewGuid().ToString();
+        user.RefreshToken = refreshToken;
+        user.RefreshTokenExpiryUtc = DateTime.UtcNow.AddDays(7);
+        await _userManager.UpdateAsync(user);
+
+        return (tokenString, refreshToken, tokenDescriptor.Expires.Value);
+    }
+}
--- a/PlaylistShared.Api/Services/SharedPlaylistService.cs
+++ b/PlaylistShared.Api/Services/SharedPlaylistService.cs
@@ -0,0 +1,136 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using PlaylistShared.Api.Data;
+using PlaylistShared.Api.Entities;
+using PlaylistShared.Shared.DTO;
+using PlaylistShared.Shared.Enums;
+using PlaylistShared.Shared.Models;
+
+namespace PlaylistShared.Api.Services;
+
+public class SharedPlaylistService
+{
+    private readonly ApplicationDbContext _db;
+    private readonly IMapper _mapper;
+    private readonly TrackAdditionLogService _trackLogService;
+
+    public SharedPlaylistService(ApplicationDbContext db, IMapper mapper, TrackAdditionLogService trackLogService)
+    {
+        _db = db;
+        _mapper = mapper;
+        _trackLogService = trackLogService;
+    }
+
+    public async Task<SharedPlaylistDto> CreateAsync(Guid creatorUserId, SharePlaylistDto dto)
+    {
+        var entity = new SharedPlaylistEntity
+        {
+            Id = Guid.NewGuid(),
+            CreatorUserId = creatorUserId,
+            YandexPlaylistKind = dto.YandexPlaylistKind,
+            YandexPlaylistOwnerUid = dto.YandexPlaylistOwnerUid,
+            Title = dto.Title,
+            Description = dto.Description,
+            CreatedAt = DateTime.UtcNow,
+            UpdatedAt = DateTime.UtcNow,
+            ShareToken = GenerateToken(),
+            ViewPermission = dto.ViewPermission,
+            AddPermission = dto.AddPermission,
+            RemovePermission = dto.RemovePermission
+        };
+        _db.SharedPlaylists.Add(entity);
+        await _db.SaveChangesAsync();
+        return _mapper.Map<SharedPlaylistDto>(entity);
+    }
+
+    public async Task<SharedPlaylistDto?> GetByTokenAsync(string token)
+    {
+        var entity = await _db.SharedPlaylists
+            .Include(sp => sp.Creator)
+            .FirstOrDefaultAsync(sp => sp.ShareToken == token && !sp.IsDeleted);
+        return entity == null ? null : _mapper.Map<SharedPlaylistDto>(entity);
+    }
+
+    public async Task<SharedPlaylistEntity?> GetEntityByTokenAsync(string token)
+    {
+        return await _db.SharedPlaylists
+            .Include(sp => sp.Creator)
+            .FirstOrDefaultAsync(sp => sp.ShareToken == token && !sp.IsDeleted);
+    }
+
+    public async Task<SharedPlaylistDto?> UpdatePermissionsAsync(Guid playlistId, UpdatePermissionsDto dto)
+    {
+        var entity = await _db.SharedPlaylists.FindAsync(playlistId);
+        if (entity == null) return null;
+        entity.ViewPermission = dto.ViewPermission;
+        entity.AddPermission = dto.AddPermission;
+        entity.RemovePermission = dto.RemovePermission;
+        entity.UpdatedAt = DateTime.UtcNow;
+        await _db.SaveChangesAsync();
+        return _mapper.Map<SharedPlaylistDto>(entity);
+    }
+
+    public async Task<bool> DeleteAsync(Guid playlistId)
+    {
+        var entity = await _db.SharedPlaylists.FindAsync(playlistId);
+        if (entity == null) return false;
+        entity.IsDeleted = true;
+        entity.UpdatedAt = DateTime.UtcNow;
+        await _db.SaveChangesAsync();
+        return true;
+    }
+
+    public async Task<bool> CanViewAsync(SharedPlaylistEntity playlist, Guid? currentUserId)
+    {
+        if (currentUserId == playlist.CreatorUserId) return true;
+        return playlist.ViewPermission == ViewPermission.Everyone ||
+               (playlist.ViewPermission == ViewPermission.AuthorizedOnly && currentUserId.HasValue);
+    }
+
+    public async Task<bool> CanAddTrackAsync(SharedPlaylistEntity playlist, Guid? currentUserId)
+    {
+        if (currentUserId == playlist.CreatorUserId) return true;
+        return playlist.AddPermission == EditPermission.Everyone ||
+               (playlist.AddPermission == EditPermission.AuthorizedOnly && currentUserId.HasValue);
+    }
+
+    public async Task<bool> CanRemoveTrackAsync(SharedPlaylistEntity playlist, Guid? currentUserId, string trackId)
+    {
+        if (currentUserId == playlist.CreatorUserId) return true;
+        return playlist.RemovePermission switch
+        {
+            EditPermission.Everyone => true,
+            EditPermission.AuthorizedOnly => currentUserId.HasValue,
+            EditPermission.AddedByUserOnly when currentUserId.HasValue =>
+                await _trackLogService.IsTrackAddedByUserAsync(playlist.Id, trackId, currentUserId.Value),
+            _ => false
+        };
+    }
+
+    public async Task<bool> IsCreatorAsync(Guid playlistId, Guid userId)
+    {
+        var playlist = await _db.SharedPlaylists.FindAsync(playlistId);
+        return playlist != null && playlist.CreatorUserId == userId;
+    }
+
+    private string GenerateToken()
+    {
+        return Convert.ToBase64String(Guid.NewGuid().ToByteArray())
+            .Replace("/", "_")
+            .Replace("+", "-")
+            .TrimEnd('=');
+    }
+
+    public async Task<SharedPlaylistEntity?> GetByYandexIdsAsync(string ownerUid, string kind)
+    {
+        return await _db.SharedPlaylists
+            .FirstOrDefaultAsync(sp => sp.YandexPlaylistOwnerUid == ownerUid && sp.YandexPlaylistKind == kind && !sp.IsDeleted);
+    }
+
+    public async Task<List<SharedPlaylistEntity>> GetAllByUserAsync(Guid userId)
+    {
+        return await _db.SharedPlaylists
+            .Where(sp => sp.CreatorUserId == userId && !sp.IsDeleted)
+            .ToListAsync();
+    }
+}
--- a/PlaylistShared.Api/Services/TrackAdditionLogService.cs
+++ b/PlaylistShared.Api/Services/TrackAdditionLogService.cs
@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore;
+using PlaylistShared.Api.Data;
+using PlaylistShared.Api.Entities;
+
+namespace PlaylistShared.Api.Services;
+
+public class TrackAdditionLogService
+{
+    private readonly ApplicationDbContext _db;
+
+    public TrackAdditionLogService(ApplicationDbContext db)
+    {
+        _db = db;
+    }
+
+    public async Task LogAdditionAsync(Guid sharedPlaylistId, string trackId, Guid addedByUserId)
+    {
+        var log = new TrackAdditionLogEntity
+        {
+            Id = Guid.NewGuid(),
+            SharedPlaylistId = sharedPlaylistId,
+            TrackId = trackId,
+            AddedByUserId = addedByUserId,
+            AddedAtUtc = DateTime.UtcNow
+        };
+        _db.TrackAdditionLogs.Add(log);
+        await _db.SaveChangesAsync();
+    }
+
+    public async Task<bool> IsTrackAddedByUserAsync(Guid sharedPlaylistId, string trackId, Guid userId)
+    {
+        return await _db.TrackAdditionLogs
+            .AnyAsync(l => l.SharedPlaylistId == sharedPlaylistId && l.TrackId == trackId && l.AddedByUserId == userId);
+    }
+
+    public async Task RemoveLogsForTrackAsync(Guid sharedPlaylistId, string trackId)
+    {
+        var logs = await _db.TrackAdditionLogs
+            .Where(l => l.SharedPlaylistId == sharedPlaylistId && l.TrackId == trackId)
+            .ToListAsync();
+        _db.TrackAdditionLogs.RemoveRange(logs);
+        await _db.SaveChangesAsync();
+    }
+}
--- a/PlaylistShared.Api/Services/YandexMusicService.cs
+++ b/PlaylistShared.Api/Services/YandexMusicService.cs
@@ -0,0 +1,88 @@
+using Microsoft.AspNetCore.DataProtection;
+using PlaylistShared.Api.Entities;
+using YandexMusic;
+using YandexMusic.API.Extensions.API;
+using YandexMusic.API.Models.Playlist;
+
+namespace PlaylistShared.Api.Services;
+
+public class YandexMusicService
+{
+    private readonly IDataProtector _dataProtector;
+
+    public YandexMusicService(IDataProtectionProvider provider)
+    {
+        _dataProtector = provider.CreateProtector("YandexTokens");
+    }
+
+    private async Task<YandexMusicClient?> CreateClientAsync(ApplicationUser user)
+    {
+        if (string.IsNullOrEmpty(user.YandexAccessToken))
+            return null;
+
+        string decryptedToken;
+        try
+        {
+            decryptedToken = _dataProtector.Unprotect(user.YandexAccessToken);
+        }
+        catch
+        {
+            return null;
+        }
+
+        var client = new YandexMusicClient();
+        var success = await client.Authorize(decryptedToken);
+        return success ? client : null;
+    }
+
+    public async Task<YPlaylist?> GetPlaylistAsync(ApplicationUser user, string ownerUid, string kind)
+    {
+        var client = await CreateClientAsync(user);
+        if (client == null) return null;
+        return await client.GetPlaylistAsync(ownerUid, kind);
+    }
+
+    public async Task<YPlaylist?> CreatePlaylistAsync(ApplicationUser user, string title)
+    {
+        var client = await CreateClientAsync(user);
+        if (client == null) return null;
+        return await client.CreatePlaylistAsync(title);
+    }
+
+    public async Task<YPlaylist?> AddTracksAsync(ApplicationUser user, string ownerUid, string kind, IEnumerable<string> trackIds)
+    {
+        var client = await CreateClientAsync(user);
+        if (client == null) return null;
+        // Получаем треки по ID
+        var tracks = await client.GetTracksAsync(trackIds);
+        if (tracks == null || !tracks.Any()) return null;
+        var playlist = await client.GetPlaylistAsync(ownerUid, kind);
+        if (playlist == null) return null;
+        return await playlist.InsertTracksAsync(tracks.ToArray());
+    }
+
+    public async Task<YPlaylist?> RemoveTracksAsync(ApplicationUser user, string ownerUid, string kind, IEnumerable<string> trackIds)
+    {
+        var client = await CreateClientAsync(user);
+        if (client == null) return null;
+        var tracks = await client.GetTracksAsync(trackIds);
+        if (tracks == null || !tracks.Any()) return null;
+        var playlist = await client.GetPlaylistAsync(ownerUid, kind);
+        if (playlist == null) return null;
+        return await playlist.RemoveTracksAsync(tracks.ToArray());
+    }
+
+    public string EncryptToken(string token) => _dataProtector.Protect(token);
+
+    public string DecryptToken(string encryptedToken)
+    {
+        try
+        {
+            return _dataProtector.Unprotect(encryptedToken);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}