Asp.net l2 lesson4

Common/WebStore.Domain/DTO/Identity/ClaimDTO.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+
+namespace WebStore.Domain.DTO.Identity
+{
+    public abstract class ClaimDTO : UserDTO
+    {
+        public IEnumerable<Claim> Claims { get; set; }
+    }
+
+    public class AddClaimDTO : ClaimDTO { }
+
+    public class RemoveClaimDTO : ClaimDTO { }
+
+    public class ReplaceClaimDTO : UserDTO
+    {
+        public Claim Claim { get; set; }
+
+        public Claim NewClaim { get; set; }
+    }
+}

Common/WebStore.Domain/DTO/Identity/UserDTO.cs

@@ -0,0 +1,26 @@
+using System;
+using Microsoft.AspNetCore.Identity;
+using WebStore.Domain.Entities.Identity;
+
+namespace WebStore.Domain.DTO.Identity
+{
+    public abstract class UserDTO
+    {
+        public User User { get; set; }
+    }
+
+    public class AddLoginDTO : UserDTO
+    {
+        public UserLoginInfo UserLoginInfo { get; set; }
+    }
+
+    public class PasswordHashDTO : UserDTO
+    {
+        public string Hash { get; set; }
+    }
+
+    public class SetLockoutDTO : UserDTO
+    {
+        public DateTimeOffset? LockoutEnd { get; set; }
+    }
+}

Common/WebStore.Domain/DTO/Orders/OrderDTO.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using WebStore.Domain.ViewModels;
+
+namespace WebStore.Domain.DTO.Orders
+{
+    public record OrderItemDTO(int Id, decimal Price, int Quantity);
+
+    public record OrderDTO(
+        int Id, 
+        string Name, 
+        string Phone, 
+        string Address, 
+        DateTime Date, 
+        IEnumerable<OrderItemDTO> Items);
+
+    public record CreateOrderModel(OrderViewModel Order, IList<OrderItemDTO> Items);
+}

Common/WebStore.Domain/DTO/Products/BrandDTO.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WebStore.Domain.Entities.Base;
+
+namespace WebStore.Domain.DTO.Products
+{
+    public class BrandDTO: NamedEntity
+    {
+        public int Order { get; set; }
+
+        public int ProductsCount { get; set; }
+    }
+}

Common/WebStore.Domain/DTO/Products/CategoryDTO.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WebStore.Domain.Entities.Base;
+
+namespace WebStore.Domain.DTO.Products
+{
+    public class CategoryDTO: NamedEntity
+    {
+
+        public int Order { get; set; }
+
+        public int? ParentId { get; set; }
+
+        public int ProductsCount { get; set; }
+    }
+}

Common/WebStore.Domain/DTO/Products/ProductDTO.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WebStore.Domain.Entities.Base;
+
+namespace WebStore.Domain.DTO.Products
+{
+    public class ProductDTO: NamedEntity
+    {
+        public int Order { get; set; }
+        public decimal Price { get; set; }
+        public string ImageUrl { get; set; }
+        public BrandDTO Brand { get; set; }
+        public CategoryDTO Category { get; set; }
+        public string Description { get; set; }
+        public int Discount { get; set; }
+
+    }
+}

Common/WebStore.Domain/ViewModels/UserOrderViewModel.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace WebStore.Domain.ViewModels
+{
+    public class UserOrderViewModel
+    {
+        public int Id { get; set; }
+
+        [Required]
+        public string Name { get; set; }
+
+        [Required]
+        public string Phone { get; set; }
+
+        [Required]
+        public string Address { get; set; }
+
+        public decimal TotalSum { get; set; }
+    }
+}

Common/WebStore.Domain/WebStore.Domain.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

Services/WebStore.Client/Base/BaseClient.cs

@@ -1,11 +1,13 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 
 namespace WebStore.Client.Base
 {
-    public abstract class BaseClient
+    public abstract class BaseClient : IDisposable
     {
         protected string Address { get; }
         protected HttpClient Http { get; }
@@ -22,5 +24,46 @@ protected BaseClient(IConfiguration Configuration, string ServiceAddress)
                 }
             };
         }
+
+        protected T Get<T>(string url) => GetAsync<T>(url).Result;
+        protected async Task<T> GetAsync<T>(string url, CancellationToken Cancel = default)
+        {
+            var response = await Http.GetAsync(url, Cancel);
+            return await response.EnsureSuccessStatusCode().Content.ReadAsAsync<T>(Cancel);
+        }
+
+        protected HttpResponseMessage Post<T>(string url, T item) => PostAsync(url, item).Result;
+        protected async Task<HttpResponseMessage> PostAsync<T>(string url, T item, CancellationToken Cancel = default)
+        {
+            var response = await Http.PostAsJsonAsync(url, item, Cancel);
+            return response.EnsureSuccessStatusCode();
+        }
+
+        protected HttpResponseMessage Put<T>(string url, T item) => PutAsync(url, item).Result;
+        protected async Task<HttpResponseMessage> PutAsync<T>(string url, T item, CancellationToken Cancel = default)
+        {
+            var response = await Http.PutAsJsonAsync(url, item, Cancel);
+            return response.EnsureSuccessStatusCode();
+        }
+
+        protected HttpResponseMessage Delete(string url) => DeleteAsync(url).Result;
+        protected async Task<HttpResponseMessage> DeleteAsync(string url, CancellationToken Cancel = default)
+        {
+            var response = await Http.DeleteAsync(url, Cancel);
+            return response;
+        }
+
+        public void Dispose() => Dispose(true);
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing)
+            {
+                // освобождение управляемых ресурсов
+                Http.Dispose();
+            }
+
+            // освобождение неуправляемых ресурсов
+        }
     }
 }

Services/WebStore.Client/Employees/EmployeesClient.cs

@@ -0,0 +1,37 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using Webstore.Interfaces;
+using Webstore.Interfaces.Services;
+using WebStore.Client.Base;
+using WebStore.Domain.Models;
+
+namespace WebStore.Client.Employees
+{
+    public class EmployeesClient: BaseClient, IEmployeesData
+    {
+        private readonly ILogger<EmployeesClient> _Logger;
+
+        public EmployeesClient(IConfiguration Configuration, ILogger<EmployeesClient> Logger): base(Configuration, WebAPI.Employees)
+        {
+            _Logger = Logger;
+        }
+
+        public int Add(Employee employee)=>Post(Address,employee).Content.ReadAsAsync<int>().Result;
+
+        public bool Delete(int id) => Delete($"{Address}/{id}").IsSuccessStatusCode;
+
+        public IEnumerable<Employee> Get() => Get<IEnumerable<Employee>>(Address);
+
+        public Employee Get(int id) => Get<Employee>($"{Address}/{id}");
+
+        public void Update(Employee employee)
+        {
+            _Logger.LogInformation("Редактирование сотрудника с id:{ 0}", employee.Id);
+            Put(Address, employee);
+        }
+    }
+}

Services/WebStore.Client/Identity/IdentityExtensions.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.DependencyInjection;
+using WebStore.Domain.Entities.Identity;
+
+namespace WebStore.Clients.Identity
+{
+    public static class IdentityExtensions
+    {
+        public static IServiceCollection AddIdentityWebStoreWebAPIClients(this IServiceCollection services)
+        {
+            services
+               .AddTransient<IUserStore<User>, UsersClient>()
+               .AddTransient<IUserRoleStore<User>, UsersClient>()
+               .AddTransient<IUserPasswordStore<User>, UsersClient>()
+               .AddTransient<IUserEmailStore<User>, UsersClient>()
+               .AddTransient<IUserPhoneNumberStore<User>, UsersClient>()
+               .AddTransient<IUserTwoFactorStore<User>, UsersClient>()
+               .AddTransient<IUserClaimStore<User>, UsersClient>()
+               .AddTransient<IUserLoginStore<User>, UsersClient>();
+
+            services.AddTransient<IRoleStore<Role>, RolesClient>();
+
+            return services;
+        }
+
+        public static IdentityBuilder AddIdentityWebStoreWebAPIClients(this IdentityBuilder builder)
+        {
+            builder.Services.AddIdentityWebStoreWebAPIClients();
+            return builder;
+        }
+    }
+}

Services/WebStore.Client/Identity/RolesClient.cs

@@ -0,0 +1,77 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Configuration;
+using Webstore.Interfaces;
+using WebStore.Client.Base;
+using WebStore.Domain.Entities.Identity;
+using WebStore.Interfaces.Services.Identity;
+
+namespace WebStore.Clients.Identity
+{
+    public class RolesClient : BaseClient, IRolesClient
+    {
+        public RolesClient(IConfiguration Configuration) : base(Configuration, WebAPI.Identity.Role) { }
+
+        #region IRoleStore<Role>
+
+        public async Task<IdentityResult> CreateAsync(Role role, CancellationToken cancel) =>
+            await (await PostAsync(Address, role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<bool>(cancel)
+                ? IdentityResult.Success
+                : IdentityResult.Failed();
+
+        public async Task<IdentityResult> UpdateAsync(Role role, CancellationToken cancel) =>
+            await (await PutAsync(Address, role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<bool>(cancel)
+                ? IdentityResult.Success
+                : IdentityResult.Failed();
+
+        public async Task<IdentityResult> DeleteAsync(Role role, CancellationToken cancel) =>
+            await (await PostAsync($"{Address}/Delete", role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<bool>(cancel)
+                ? IdentityResult.Success
+                : IdentityResult.Failed();
+
+        public async Task<string> GetRoleIdAsync(Role role, CancellationToken cancel) =>
+            await (await PostAsync($"{Address}/GetRoleId", role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<string>(cancel);
+
+        public async Task<string> GetRoleNameAsync(Role role, CancellationToken cancel) =>
+            await (await PostAsync($"{Address}/GetRoleName", role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<string>(cancel);
+
+        public async Task SetRoleNameAsync(Role role, string name, CancellationToken cancel)
+        {
+            var response = await PostAsync($"{Address}/SetRoleName/{name}", role, cancel).ConfigureAwait(false);
+            role.Name = await response.Content.ReadAsAsync<string>(cancel);
+        }
+
+        public async Task<string> GetNormalizedRoleNameAsync(Role role, CancellationToken cancel) =>
+            await (await PostAsync($"{Address}/GetNormalizedRoleName", role, cancel).ConfigureAwait(false))
+               .Content
+               .ReadAsAsync<string>(cancel);
+
+        public async Task SetNormalizedRoleNameAsync(Role role, string name, CancellationToken cancel)
+        {
+            var response = await PostAsync($"{Address}/SetNormalizedRoleName/{name}", role, cancel).ConfigureAwait(false);
+            role.NormalizedName = await response.Content.ReadAsAsync<string>(cancel);
+        }
+
+        public async Task<Role> FindByIdAsync(string id, CancellationToken cancel) =>
+            await GetAsync<Role>($"{Address}/FindById/{id}", cancel)
+               .ConfigureAwait(false);
+
+        public async Task<Role> FindByNameAsync(string name, CancellationToken cancel) =>
+            await GetAsync<Role>($"{Address}/FindByName/{name}", cancel)
+               .ConfigureAwait(false);
+
+        #endregion
+    }
+}