Добален поиск по трекам

PlaylistShared.Api/Controllers/YandexSearchController.cs

@@ -0,0 +1,74 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using PlaylistShared.Api.Entities;
+using PlaylistShared.Api.Extensions;
+using PlaylistShared.Api.Services;
+using PlaylistShared.Shared;
+using PlaylistShared.Shared.DTO;
+
+namespace PlaylistShared.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+[AllowAnonymous]
+public class YandexSearchController : ControllerBase
+{
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly YandexMusicService _yandexService;
+    private readonly SharedPlaylistService _sharedPlaylistService;
+
+    public YandexSearchController(UserManager<ApplicationUser> userManager, YandexMusicService yandexService, SharedPlaylistService sharedPlaylistService)
+    {
+        _userManager = userManager;
+        _yandexService = yandexService;
+        _sharedPlaylistService = sharedPlaylistService;
+    }
+
+    [HttpGet("tracks")]
+    public async Task<ActionResult<ApiResponse<List<YandexTrackSearchResult>>>> SearchTracks(
+        [FromQuery] string query,
+        [FromQuery] int limit = 20,
+        [FromQuery] string? shared_id = null)
+    {
+        if (string.IsNullOrWhiteSpace(query))
+            return BadRequest(ApiResponse<List<YandexTrackSearchResult>>.Fail(new ErrorResponse
+            {
+                StatusCode = 400,
+                Message = "Поисковый запрос не может быть пустым."
+            }));
+
+        ApplicationUser? user = null;
+        var userId = User.GetUserIdOrNull();
+        if (userId.HasValue)
+            user = await _userManager.FindByIdAsync(userId.Value.ToString());
+
+        // Если нет пользователя или у него нет токена, пробуем через shared_id
+        if (user == null || string.IsNullOrEmpty(_yandexService.DecryptToken(user.YandexAccessToken)))
+        {
+            if (string.IsNullOrEmpty(shared_id))
+                return Unauthorized("Не установлен яндекс токен.");
+
+            var playlist = await _sharedPlaylistService.GetEntityByTokenAsync(shared_id);
+            if (playlist == null) return NotFound("Не найден плейлист.");
+
+            if (!await _sharedPlaylistService.CanAddTrackAsync(playlist, userId))
+                return StatusCode(403, "Нет доступа для добавления трека.");
+
+            var owner = await _userManager.FindByIdAsync(playlist.CreatorUserId.ToString());
+            if (owner == null) return StatusCode(500, "Не удалось найти владельца плейлиста.");
+            user = owner;
+        }
+
+        var decryptedToken = _yandexService.DecryptToken(user.YandexAccessToken);
+        if (string.IsNullOrEmpty(decryptedToken))
+            return BadRequest(ApiResponse<List<YandexTrackSearchResult>>.Fail(new ErrorResponse
+            {
+                StatusCode = 400,
+                Message = "Токен Яндекс.Музыки не установлен или недействителен."
+            }));
+
+        var results = await _yandexService.SearchTracksAsync(user, query, limit);
+        return Ok(ApiResponse<List<YandexTrackSearchResult>>.Ok(results));
+    }
+}

PlaylistShared.Api/Services/YandexMusicService.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.DataProtection;
 using PlaylistShared.Api.Entities;
+using PlaylistShared.Shared.DTO;
 using YandexMusic;
 using YandexMusic.API.Extensions.API;
 using YandexMusic.API.Models.Playlist;
@@ -94,4 +95,22 @@ public class YandexMusicService
             return null;
         }
     }
+
+    public async Task<List<YandexTrackSearchResult>> SearchTracksAsync(ApplicationUser user, string query, int limit = 20)
+    {
+        var client = await CreateClientAsync(user);
+        if (client == null) return new List<YandexTrackSearchResult>();
+
+        var searchResult = await client.SearchAsync(query, YandexMusic.API.Models.Common.YSearchType.Track, page: 0, pageSize: limit);
+        if (searchResult?.Tracks?.Results == null) return new List<YandexTrackSearchResult>();
+
+        return searchResult.Tracks.Results.Select(t => new YandexTrackSearchResult
+        {
+            TrackId = t.Id,
+            Title = t.Title,
+            Artists = t.Artists?.Select(a => a.Name).ToList() ?? new List<string>(),
+            CoverUri = t.CoverUri ?? string.Empty,
+            DurationMs = t.DurationMs,
+        }).ToList();
+    }
 }

PlaylistShared.Pwa/Components/ShareButton.razor

@@ -1,5 +1,6 @@
 @inject IJSRuntime JS
 @inject ISnackbar Snackbar
+@inject NavigationManager Navigation
 
 <MudIconButton @ref="_buttonRef"
                Icon="@Icons.Material.Filled.Share"

PlaylistShared.Pwa/Components/SharedPlaylist/AddTrackBySearch.razor

@@ -0,0 +1,147 @@
+@using PlaylistShared.Shared.DTO
+@inject HttpClient Http
+@inject ISnackbar Snackbar
+
+<MudPaper Class="pa-4" Elevation="0" Style="background-color: rgba(0,0,0,0.05); border-radius: 8px;">
+    <MudText Typo="Typo.h6" GutterBottom>Поиск трека</MudText>
+    
+    <div style="display: flex; gap: 8px; margin-bottom: 16px;">
+        <MudTextField @bind-Value="_searchQuery"
+                      Label="Название трека или исполнитель"
+                      Variant="Variant.Outlined"
+                      FullWidth="true"
+                      OnKeyDown="@(async (e) => { if (e.Key == "Enter") await SearchTracks(); })"
+                      Placeholder="Например: Bohemian Rhapsody" />
+        <MudButton Variant="Variant.Filled"
+                   Color="Color.Primary"
+                   OnClick="SearchTracks"
+                   Disabled="_isSearching"
+                   StartIcon="@Icons.Material.Filled.Search">
+            Искать
+        </MudButton>
+    </div>
+
+    @if (_isSearching)
+    {
+        <div style="text-align: center; padding: 20px;">
+            <MudProgressCircular Indeterminate />
+        </div>
+    }
+    else if (_searchResults.Any())
+    {
+        <div style="max-height: 400px; overflow-y: auto;">
+            @foreach (var track in _searchResults)
+            {
+                <div style="display: flex; align-items: center; gap: 12px; padding: 8px; border-bottom: 1px solid rgba(0,0,0,0.1);">
+                    <div style="width: 40px; height: 40px; flex-shrink: 0;">
+                        <TrackCoverWithPlay CoverUrl="@track.CoverUri"
+                                            TrackId="@track.TrackId"
+                                            Width="40" Height="40"
+                                            IsPlaying="@(_currentPlayingTrackId == track.TrackId && _isPlaying)"
+                                            OnPlay="PlayTrack" />
+                    </div>
+                    <div style="flex: 1; min-width: 0;">
+                        <MudText Typo="Typo.body1" Style="font-weight: 500;">@track.Title</MudText>
+                        <MudText Typo="Typo.body2" Color="Color.Secondary">@string.Join(", ", track.Artists)</MudText>
+                    </div>
+                    <div style="flex-shrink: 0;">
+                        <MudText Typo="Typo.body2">@FormatDuration(track.DurationMs)</MudText>
+                    </div>
+                    <div style="flex-shrink: 0;">
+                        <MudIconButton Icon="@Icons.Material.Filled.AddCircle"
+                                       Color="Color.Primary"
+                                       OnClick="() => AddTrack(track)"
+                                       Disabled="_addingTrackIds.Contains(track.TrackId)"
+                                       Title="Добавить в плейлист" />
+                    </div>
+                </div>
+            }
+        </div>
+    }
+    else if (!string.IsNullOrEmpty(_searchQuery) && !_isSearching)
+    {
+        <MudAlert Severity="Severity.Info">Ничего не найдено. Попробуйте изменить запрос.</MudAlert>
+    }
+</MudPaper>
+
+@code {
+    [Parameter] public EventCallback<string> OnAddTrack { get; set; }
+    [Parameter] public EventCallback<string> OnPlayTrack { get; set; }
+    [Parameter] public string ShareToken { get; set; } = string.Empty;
+    [Parameter] public string? CurrentPlayingTrackId { get; set; }
+    [Parameter] public bool IsPlaying { get; set; }
+
+    private string _searchQuery = "";
+    private List<YandexTrackSearchResult> _searchResults = new();
+    private bool _isSearching;
+    private HashSet<string> _addingTrackIds = new();
+    private string? _currentPlayingTrackId;
+    private bool _isPlaying;
+
+    protected override void OnParametersSet()
+    {
+        _currentPlayingTrackId = CurrentPlayingTrackId;
+        _isPlaying = IsPlaying;
+    }
+
+    private async Task SearchTracks()
+    {
+        if (string.IsNullOrWhiteSpace(_searchQuery)) return;
+        
+        _isSearching = true;
+        try
+        {
+            var url = $"/api/yandexsearch/tracks?query={Uri.EscapeDataString(_searchQuery)}&limit=20";
+            if (!string.IsNullOrEmpty(ShareToken))
+                url += $"&shared_id={Uri.EscapeDataString(ShareToken)}";
+
+            var response = await Http.GetFromJsonAsync<ApiResponse<List<YandexTrackSearchResult>>>(url);
+            if (response?.Success == true)
+                _searchResults = response.Data ?? new();
+            else
+                Snackbar.Add(response?.Error?.Message ?? "Ошибка поиска", Severity.Error);
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _isSearching = false;
+            StateHasChanged();
+        }
+    }
+
+    private async Task AddTrack(YandexTrackSearchResult track)
+    {
+        if (_addingTrackIds.Contains(track.TrackId)) return;
+        _addingTrackIds.Add(track.TrackId);
+        try
+        {
+            await OnAddTrack.InvokeAsync(track.TrackId);
+            Snackbar.Add($"Трек \"{track.Title}\" добавлен", Severity.Success);
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Ошибка добавления: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _addingTrackIds.Remove(track.TrackId);
+            StateHasChanged();
+        }
+    }
+
+    private async Task PlayTrack(string trackId)
+    {
+        await OnPlayTrack.InvokeAsync(trackId);
+    }
+
+    private string FormatDuration(long ms)
+    {
+        var seconds = ms / 1000;
+        var mins = seconds / 60;
+        var secs = seconds % 60;
+        return $"{mins}:{secs:D2}";
+    }
+}

PlaylistShared.Pwa/Components/SharedPlaylist/AddTrackSection.razor

@@ -0,0 +1,112 @@
+@using PlaylistShared.Shared.Shared
+@inject HttpClient Http
+@inject ISnackbar Snackbar
+
+<MudPaper Class="mb-4" Elevation="0" Style="background-color: rgba(0,0,0,0.05); border-radius: 8px;">
+    <MudTabs @bind-ActivePanelIndex="_activeTabIndex" Elevation="0" Style="border-bottom: 1px solid rgba(0,0,0,0.1);">
+        <MudTabPanel Text="По ссылке" Style="padding: 16px;">
+            <MudGrid>
+                <MudItem xs="12" sm="10">
+                    <MudTextField @bind-Value="_trackLink" Label="Ссылка на трек Яндекс.Музыки"
+                                  Variant="Variant.Outlined" FullWidth="true"
+                                  Placeholder="https://music.yandex.ru/album/2488464/track/21696942" />
+                </MudItem>
+                <MudItem xs="12" sm="2">
+                    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="AddTrackByLink"
+                               Disabled="_addingTrack" FullWidth="true" Style="height: 100%;">
+                        @if (_addingTrack)
+                        {
+                            <MudProgressCircular Size="Size.Small" Indeterminate />
+                        }
+                        else
+                        {
+                            <span>Добавить</span>
+                        }
+                    </MudButton>
+                </MudItem>
+            </MudGrid>
+            <MudText Typo="Typo.body2" Class="mt-2" Color="Color.Secondary">
+                Поддерживаются ссылки вида: https://music.yandex.ru/album/12345/track/67890
+            </MudText>
+        </MudTabPanel>
+        <MudTabPanel Text="Поиск" Style="padding: 16px;">
+            <AddTrackBySearch OnAddTrack="AddTrackById"
+                              OnPlayTrack="PlayTrack"
+                              CurrentPlayingTrackId="CurrentPlayingTrackId"
+                              IsPlaying="IsPlaying"
+                              ShareToken="@ShareToken" />
+        </MudTabPanel>
+    </MudTabs>
+</MudPaper>
+
+@code {
+    private int _activeTabIndex = 0;
+    private string _trackLink = "";
+    private bool _addingTrack = false;
+
+    [Parameter] public string ShareToken { get; set; } = string.Empty;
+    [Parameter] public EventCallback OnTrackAdded { get; set; }
+    [Parameter] public EventCallback<string> OnPlayTrack { get; set; }
+    [Parameter] public string? CurrentPlayingTrackId { get; set; }
+    [Parameter] public bool IsPlaying { get; set; }
+
+    private async Task AddTrackByLink()
+    {
+        if (string.IsNullOrWhiteSpace(_trackLink))
+        {
+            Snackbar.Add("Введите ссылку на трек", Severity.Warning);
+            return;
+        }
+
+        var trackId = ExtractTrackIdFromLink(_trackLink);
+        if (string.IsNullOrEmpty(trackId))
+        {
+            Snackbar.Add("Неверный формат ссылки", Severity.Warning);
+            return;
+        }
+
+        await AddTrackById(trackId);
+        if (!_addingTrack) // если не было ошибки
+            _trackLink = "";
+    }
+
+    private async Task AddTrackById(string trackId)
+    {
+        _addingTrack = true;
+        try
+        {
+            var request = new AddTracksRequest { TrackIds = new List<string> { trackId } };
+            var response = await Http.PostAsJsonAsync($"/api/sharedplaylist/{ShareToken}/add-tracks", request);
+            if (response.IsSuccessStatusCode)
+            {
+                Snackbar.Add("Трек успешно добавлен", Severity.Success);
+                await OnTrackAdded.InvokeAsync(); // уведомляем родителя, что список треков изменился
+            }
+            else
+            {
+                var error = await response.Content.ReadFromJsonAsync<ApiResponse<object>>();
+                Snackbar.Add(error?.Error?.Message ?? "Ошибка добавления трека", Severity.Error);
+            }
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _addingTrack = false;
+            StateHasChanged();
+        }
+    }
+
+    private async Task PlayTrack(string trackId)
+    {
+        OnPlayTrack.InvokeAsync(trackId);
+    }
+
+    private string? ExtractTrackIdFromLink(string link)
+    {
+        var match = System.Text.RegularExpressions.Regex.Match(link, @"/track/(\d+)");
+        return match.Success ? match.Groups[1].Value : null;
+    }
+}

PlaylistShared.Pwa/Pages/SharedPlaylistView.razor

@@ -1,4 +1,5 @@
 @page "/shared/{token}"
+@using PlaylistShared.Pwa.Components.SharedPlaylist
 @using PlaylistShared.Shared.DTO
 @using PlaylistShared.Shared.Enums
 @using PlaylistShared.Pwa.Services
@@ -60,36 +61,13 @@
             </MudCardHeader>
 
             <MudCardContent>
-                <!-- Блок добавления трека (только для авторизованных с правом добавления) -->
                 @if (_canAdd)
                 {
-                    <MudPaper Class="pa-4 mb-4" Elevation="0" Style="background-color: rgba(0,0,0,0.05); border-radius: 8px;">
+                    <AddTrackSection ShareToken="@Token"
-                        <MudText Typo="Typo.h6" GutterBottom>Добавить трек</MudText>
+                                     OnTrackAdded="LoadTracks"
-                        <MudGrid>
+                                     OnPlayTrack="PlayTrack"
-                            <MudItem xs="12" sm="10">
+                                     CurrentPlayingTrackId="_currentTrackId"
-                                <MudTextField @bind-Value="_trackLink" Label="Ссылка на трек Яндекс.Музыки"
+                                     IsPlaying="_isPlaying" />
-                                              Variant="Variant.Outlined" FullWidth="true"
-                                              Placeholder="https://music.yandex.ru/album/2488464/track/21696942" />
-                            </MudItem>
-                            <MudItem xs="12" sm="2">
-                                <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="AddTrack"
-                                           Disabled="_addingTrack" FullWidth="true" Style="height: 100%;">
-                                    @if (_addingTrack)
-                                    {
-                                        <MudProgressCircular Size="Size.Small" Indeterminate />
-                                    }
-                                    else
-                                    {
-
-                                        <span>Добавить</span>
-                                    }
-                                </MudButton>
-                            </MudItem>
-                        </MudGrid>
-                        <MudText Typo="Typo.body2" Class="mt-2" Color="Color.Secondary">
-                            Поддерживаются ссылки вида: https://music.yandex.ru/album/12345/track/67890
-                        </MudText>
-                    </MudPaper>
                 }
 
                 <!-- Список треков -->
@@ -171,6 +149,8 @@
 @code {
     [Parameter] public string Token { get; set; }
 
+    private int _addTrackTabIndex = 0; // 0 - ссылка, 1 - поиск
+
     private AudioPlayer? _audioPlayer;
     private string? _currentTrackId { get; set; }
     private bool _isPlaying = false;
@@ -369,7 +349,7 @@
         }
     }
 
-    private async Task AddTrack()
+    private async Task AddTrackByLink()
     {
         if (string.IsNullOrWhiteSpace(_trackLink))
         {
@@ -404,6 +384,65 @@
         }
     }
 
+    private async Task OnTrackAdded(string trackId)
+    {
+        if (!_canAdd) return;
+
+        try
+        {
+            var request = new AddTracksRequest { TrackIds = new List<string> { trackId } };
+            var response = await Http.PostAsJsonAsync($"/api/sharedplaylist/{Token}/add-tracks", request);
+            if (response.IsSuccessStatusCode)
+            {
+                Snackbar.Add("Трек успешно добавлен", Severity.Success);
+                await LoadTracks();
+            }
+            else
+            {
+                var error = await response.Content.ReadFromJsonAsync<ApiResponse<object>>();
+                Snackbar.Add(error?.Error?.Message ?? "Ошибка добавления трека", Severity.Error);
+            }
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
+        }
+    }
+
+    private async Task AddTrackById(string trackId)
+    {
+        if (!_canAdd)
+        {
+            Snackbar.Add("У вас нет прав на добавление треков", Severity.Warning);
+            return;
+        }
+
+        _addingTrack = true;
+        try
+        {
+            var request = new AddTracksRequest { TrackIds = new List<string> { trackId } };
+            var response = await Http.PostAsJsonAsync($"/api/sharedplaylist/{Token}/add-tracks", request);
+            if (response.IsSuccessStatusCode)
+            {
+                Snackbar.Add("Трек успешно добавлен", Severity.Success);
+                await LoadTracks();
+            }
+            else
+            {
+                var error = await response.Content.ReadFromJsonAsync<ApiResponse<object>>();
+                Snackbar.Add(error?.Error?.Message ?? "Ошибка добавления трека", Severity.Error);
+            }
+        }
+        catch (Exception ex)
+        {
+            Snackbar.Add($"Ошибка: {ex.Message}", Severity.Error);
+        }
+        finally
+        {
+            _addingTrack = false;
+        }
+    }
+
     private async Task RemoveTrack(YandexTrackDisplay track)
     {
         var confirmed = await DialogService.ShowMessageBoxAsync(
@@ -505,6 +544,4 @@
         _isPlaying = false;
         StateHasChanged();
     }
-
-
 }

PlaylistShared.Shared/DTO/YandexTrackSearchResult.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+
+namespace PlaylistShared.Shared.DTO;
+
+/// <summary>Результат поиска трека в Яндекс.Музыке.</summary>
+public class YandexTrackSearchResult
+{
+    [JsonPropertyName("trackId")]
+    public string TrackId { get; set; } = string.Empty;
+
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    [JsonPropertyName("artists")]
+    public List<string> Artists { get; set; } = new();
+
+    [JsonPropertyName("coverUri")]
+    public string CoverUri { get; set; } = string.Empty;
+
+    [JsonPropertyName("durationMs")]
+    public long DurationMs { get; set; }
+}