Merge branch 'feature/get-user-info' into dev

GrpcShared/DTO/TokenMessage.cs

 
 namespace GrpcShared.DTO
 {
-    [ProtoContract]
+    [ProtoContract(SkipConstructor = true)]
     public class TokenMessage
     {
+        
+        public TokenMessage(string? token)
+        {
+            Token = token;
+        }
+
         [ProtoMember(1)]
         public string? Token { get; set; }
     }

GrpcShared/DTO/Track/TrackResponse.cs

     public class TrackResponse
     {
         [ProtoMember(1)]
-        public int? Timestamp{ get; set; }
+        public string? timestamp{ get; set; }
         [ProtoMember(2)]
-        public int? Progress_ms { get; set; }
+        public int? progress_ms { get; set; }
         [ProtoMember(3)]
-        public bool? Is_playing { get; set; }
+        public bool? is_playing { get; set; }
         [ProtoMember(4)]
-        public Item? Item { get; set; }
+        public Item? item { get; set; }
 
     }
     [ProtoContract]
     public class Item
     {
         [ProtoMember(1)]
-        public Album? Album { get; set; }
+        public Album? album { get; set; }
         [ProtoMember(2)]
-        public Artist[]? Artists { get; set; }
+        public Artist[]? artists { get; set; }
         [ProtoMember(3)]
-        public string? Id { get; set; }
+        public string? id { get; set; }
         [ProtoMember(4)]
-        public string? Name { get; set; }
+        public string? name { get; set; }
         [ProtoMember(5)]
-        public string? Href { get; set; }
+        public string? href { get; set; }
 
     }
     [ProtoContract]
     public class Album
     {
         [ProtoMember(1)]
-        public string? Id { get; set; }
+        public string? id { get; set; }
         [ProtoMember(2)]
-        public string? Name { get; set; }
+        public string? name { get; set; }
         [ProtoMember(3)]
-        public Image[]? Images { get; set; }
+        public Image[]? images { get; set; }
         [ProtoMember(4)]
-        public string? Href { get; set; }
+        public string? href { get; set; }
     }
     [ProtoContract]
     public class Artist
     {
         [ProtoMember(1)]
-        public string? Id { get; set; }
+        public string? id { get; set; }
         [ProtoMember(2)]
-        public string? Name { get; set; }
+        public string? name { get; set; }
         [ProtoMember(3)]
-        public string? Href { get; set; }
+        public string? href { get; set; }
     }
     [ProtoContract]
     public class Image
     {
         [ProtoMember(1)]
-        public int? Height{ get; set; }
+        public int? height{ get; set; }
         [ProtoMember(2)]
-        public string? Url { get; set; }
+        public string? url { get; set; }
         [ProtoMember(3)]
-        public int? Width { get; set; }
+        public int? width { get; set; }
     }
 }

GrpcShared/Interfaces/IStatsService.cs

-using GrpcShared.DTO.Track;
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
 using ProtoBuf.Grpc.Configuration;
 using System;
 using System.Collections.Generic;
     [Service]
     public interface IStatsService
     {
-        Task<TrackResponse> GetCurrentlyPlayingTrack(string token);
+        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

IdentityProvider/Program.cs

 //app.MapGrpcService<WeatherService>();
 app.MapGrpcService<AuthService>().EnableGrpcWeb();
 app.MapGrpcService<TrackService>().EnableGrpcWeb();
+app.MapGrpcService<StatsService>().EnableGrpcWeb();
 
 app.MapCodeFirstGrpcReflectionService();
 

IdentityProvider/Services/AuthService.cs

             //AUTHORIZATION HEADER
             http.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Basic " + Convert.ToBase64String(contentType));
 
-            //ACCEPT HEADER
-            http.DefaultRequestHeaders.Accept.Add(
-                    new MediaTypeWithQualityHeaderValue("application/json"));
+            ////ACCEPT HEADER
+            //http.DefaultRequestHeaders.Accept.Add(
+            //        new MediaTypeWithQualityHeaderValue("application/json"));
 
             //BODY PARAMS
             var requestBody = new Dictionary<string, string>();
             var response = await http.PostAsync(url, new FormUrlEncodedContent(requestBody));
 
             var contents = JsonConvert.DeserializeObject<TokenResponse>(await response.Content.ReadAsStringAsync());
-            return new TokenResponse
-            {
-                access_token = contents!.access_token,
-                refresh_token = contents!.refresh_token,
-                expires_in = contents!.expires_in
-            };
+            if (contents != null)
+                return new TokenResponse
+                {
+                    access_token = contents!.access_token,
+                    refresh_token = contents!.refresh_token,
+                    expires_in = contents!.expires_in
+                };
+            else return null;
         }
 
         public async Task<CodeRequest> GetAuthParams()

NemAnCore/App.razor

-<CascadingAuthenticationState>
+@using NemAnBlazor.Pages
+<CascadingAuthenticationState>
 <Router AppAssembly="@typeof(App).Assembly">
     <Found Context="routeData">
         <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" >

NemAnCore/AuthProvider.cs

-using Blazored.SessionStorage;
-using System.Security.Claims;
-
-namespace NemAnBlazor
-{
-    public class AuthProvider : AuthenticationStateProvider
-    {
-        private readonly ISessionStorageService _sessionStorage;
-        public AuthProvider(ISessionStorageService sessionStorage)
-        {
-            _sessionStorage = sessionStorage;
-        }
-        public override async Task<AuthenticationState> GetAuthenticationStateAsync()
-        {
-            string token = await _sessionStorage.GetItemAsync<string>("token");
-
-            ClaimsIdentity identity = new ();
-            ClaimsPrincipal user = new (identity);
-            AuthenticationState state = new(user);
-
-            NotifyAuthenticationStateChanged(Task.FromResult(state));
-
-            return state;
-        }
-    }
-}

NemAnCore/NemAnBlazor.csproj

     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <Optimize>True</Optimize>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <Optimize>False</Optimize>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Blazored.SessionStorage" Version="2.2.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.47.0" />

NemAnCore/Pages/Callback.razor

 
 
 @code {
-   
-   
+
+
     protected override async Task OnInitializedAsync()
     {
         string url = NavigationMgr.Uri;
 
         var response = await AuthService.GetAccessToken(new GrpcShared.DTO.Auth.TokenRequest { code = code});
 
+        //if (response.access_token == null) NavigationMgr.NavigateTo("/");
 
         //store access token in local storage
         await sessionStorage.SetItemAsync("token", response.access_token);
         await sessionStorage.SetItemAsync("refresh_token", response.refresh_token);
-
+        
         //redirect to home
         NavigationMgr.NavigateTo("/home");
     }

NemAnCore/Pages/FetchData.razor

     private async Task Click(){
 
         var token = await sessionStorage.GetItemAsync<string>("token");
-        TokenMessage tm = new() { Token = token };
+        TokenMessage tm = new(token) ;
                 SearchRequest request = new() { Query = "aitch", Type = "track", Token = token };
                 SearchResponse searchResponse = await SearchService.GetListSearchAsync(request);
             

NemAnCore/Pages/Home.razor

 @page "/home"
+@using GrpcShared.DTO
+@using GrpcShared.DTO.Track
+@using NemAnBlazor.Services.Interfaces
+@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
+@inject IStatsClientService spotifyService
+
 <h3>Home</h3>
 
 <p>login radi</p>
-<AuthorizeView>
-    <Authorized> 
-        <p>autorizovan si</p>
-    </Authorized>
-    <NotAuthorized>
-        <p>nisi autorizovan</p>
-    </NotAuthorized>
-</AuthorizeView>
+
 @code {
+    protected override async Task OnInitializedAsync()
+    {
+        string tokenS = await sessionStorage.GetItemAsync<string>("token");
+        TokenMessage token = new TokenMessage(tokenS);
 
+        TrackResponse response = await spotifyService.GetCurrentlyPlayingTrack(token);
+    }
 }

NemAnCore/Pages/Index.razor → NemAnCore/Pages/Login.razor

     </Authorized>
     <NotAuthorized>
             Nisi autorizovan.
-            <button class="btn btn-primary" @onclick="Login">Autorizuj</button>
+            <button class="btn btn-primary" @onclick="LoginUser">Autorizuj</button>
     </NotAuthorized>
 </AuthorizeView>
 
         message = "Cao";
     }
 
-    private async Task Login()
+    private async Task LoginUser()
     {
         //var response = await SearchService.GetListSearchAsync(new GrpcShared.DTO.Search.SearchRequest() { Query="venom", Type = "track"});
         CodeRequest authParams = await AuthService.GetAuthParams();

NemAnCore/Pages/LoginRedirect.razor

+@inject NavigationManager UriHelper
+@code {
+     protected override void OnInitialized()
+     {
+         UriHelper.NavigateTo("/");
+     }
+ } 

NemAnCore/Program.cs

 using Grpc.Net.Client;
 using Grpc.Net.Client.Web;
 using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 using NemAnBlazor;
 
 builder.Services.AddScoped<ITrackClientService, TrackClientService>();
 builder.Services.AddScoped<IAuthClientService, AuthClientService>();
+builder.Services.AddScoped<IStatsClientService, StatsClientService>();
 builder.Services.AddBlazoredSessionStorage();
-builder.Services.AddScoped<AuthenticationStateProvider, AuthProvider>();
+builder.Services.AddScoped<AuthenticationStateProvider, AuthClientService>();
 builder.Services.AddAuthorizationCore();
+
 await builder.Build().RunAsync();
 

NemAnCore/Services/AuthClientService.cs

             return await _serviceClient.GetAccessToken(request);
         }
 
+        //public override async Task<AuthenticationState> GetAuthenticationStateAsync()
+        //{
+        //    string token = await _sessionStorage.GetItemAsync<string>("token");
+
+        //    //token = "BQBMgFm6jnFNWWeZEMGIRP_f-ENPid7Kw8JubAyuWAe4JK0S1DPFGlaAdZ_Fey6ePkCnz8-cqC0oyRmrciWUy5ISUTQKDe8PTQn4iBRMYCgM0n4GnS1xAErHJcm4Vpu2TAngk-4vQUOfTQRcedNTfCaHKP4uFJgTlTI7JHGrtB-_EZLnFcZ2OQe31oFQIJ1wM3ZtvwnN";
+        //    if (token == null) return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
+            
+        //    var userInfo = await _serviceClient.GetUserInfo(new TokenMessage ( token ));
+
+        //    List<Claim> claims = new();
+
+        //    claims.Add(new Claim("email", userInfo.email!));
+        //    claims.Add(new Claim("id", userInfo.id!));
+        //    claims.Add(new Claim("name", userInfo.display_name!));
+
+        //    ClaimsIdentity identity = new(claims, "jwt");
+        //    //ClaimsIdentity identity = new();
+        //    ClaimsPrincipal user = new(identity);
+        //    AuthenticationState state = new(user);
+
+        //    NotifyAuthenticationStateChanged(Task.FromResult(state));
+
+        //    return state;
+        //}
+
         public async Task<CodeRequest> GetAuthParams()
         {
             return await _serviceClient.GetAuthParams();
             //token = "BQBMgFm6jnFNWWeZEMGIRP_f-ENPid7Kw8JubAyuWAe4JK0S1DPFGlaAdZ_Fey6ePkCnz8-cqC0oyRmrciWUy5ISUTQKDe8PTQn4iBRMYCgM0n4GnS1xAErHJcm4Vpu2TAngk-4vQUOfTQRcedNTfCaHKP4uFJgTlTI7JHGrtB-_EZLnFcZ2OQe31oFQIJ1wM3ZtvwnN";
             if (token == null) return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
 
-            var userInfo = await _serviceClient.GetUserInfo(new TokenMessage { Token = token });
+            var userInfo = await _serviceClient.GetUserInfo(new TokenMessage (token));
 
             List<Claim> claims = new();
 

NemAnCore/Services/Interfaces/IStatsClientService.cs

-namespace NemAnBlazor.Services.Interfaces
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
+
+namespace NemAnBlazor.Services.Interfaces
 {
     public interface IStatsClientService
     {
+        Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token);
     }
 }

NemAnCore/Services/StatsClientService.cs

-using NemAnBlazor.Services.Interfaces;
+using Grpc.Net.Client;
+using GrpcShared.DTO;
+using GrpcShared.DTO.Track;
+using GrpcShared.Interfaces;
+using NemAnBlazor.Services.Interfaces;
+using ProtoBuf.Grpc.Client;
 
 namespace NemAnBlazor.Services
 {
-    public class StatsClientService :IStatsClientService
+    public class StatsClientService : IStatsClientService
     {
+        private IStatsService _serviceClient;
+        public StatsClientService(GrpcChannel channel)
+        {
+            _serviceClient = channel.CreateGrpcService<IStatsService>();
+        }
+        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
+    {
+            return await _serviceClient.GetCurrentlyPlayingTrack(token);
+        }
     }
 }

gRPCServer/Services/StatsService.cs

 
+using GrpcShared.DTO;
 using GrpcShared.DTO.Track;
 using GrpcShared.Interfaces;
+using Microsoft.Net.Http.Headers;
+using Newtonsoft.Json;
 
 namespace SpotifyService.Services
 {
         {
             _httpClientFactory = httpClientFactory;
         }
-        public Task<TrackResponse> GetCurrentlyPlayingTrack(string token)
+
+        public async Task<TrackResponse> GetCurrentlyPlayingTrack(TokenMessage token)
         {
-            return null;
+            var client = _httpClientFactory.CreateClient("HttpClient");
+            client.DefaultRequestHeaders.Add(HeaderNames.Authorization, "Bearer " + token.Token);
+            
+            var searchResult = await client.GetAsync($"me/player/currently-playing");
+
+            var responses = JsonConvert.DeserializeObject<TrackResponse>(await searchResult.Content.ReadAsStringAsync())!;
+
+           return responses;
+
         }
     }
 }