Merge pull request #21 from Shchoholiev/release/v0.1.0

Release/v0.1.0

.devcontainer/devcontainer.json

@@ -0,0 +1,44 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet
+{
+	"name": "Shopping Assistant C# (.NET)",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/dotnet:0-7.0",
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [5000, 5001],
+	// "portsAttributes": {
+	//		"5001": {
+	//			"protocol": "https"
+	//		}
+	// }
+
+	// Container is not working on M1 Mac
+	// "runArgs": [
+	// 	"--platform=linux/amd64"
+	// ],
+	
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"kreativ-software.csharpextensions",
+				"ms-dotnettools.csharp",
+				"patcx.vscode-nuget-gallery",
+				"mhutchie.git-graph",
+				"fernandoescolar.vscode-solution-explorer",
+				"formulahendry.dotnet-test-explorer",
+				"GitHub.copilot"
+			]
+		}
+	}
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "dotnet restore",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.github/workflows/develop_shopping-assistant-api-dev.yml

@@ -0,0 +1,60 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/Azure/webapps-deploy
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build and deploy ASP.Net Core app to Azure Web App - shopping-assistant-api-dev
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: '7.x'
+          include-prerelease: true
+
+      - name: Build with dotnet
+        run: dotnet build --configuration Release
+
+      # - name: Integration Tests
+      #   run: dotnet test ShoppingAssistantApi.Tests --configuration Debug --verbosity normal
+
+      # - name: Unit Tests
+      #   run: dotnet test ShoppingAssistantApi.UnitTests --configuration Debug --verbosity normal
+
+      - name: dotnet publish
+        run: dotnet publish ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj -c Release -o ${{env.DOTNET_ROOT}}/myapp --no-build --no-restore
+
+      - name: Upload artifact for deployment job
+        uses: actions/upload-artifact@v3
+        with:
+          name: .net-app
+          path: ${{env.DOTNET_ROOT}}/myapp
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: 'Development'
+      url: ${{ steps.deploy-to-webapp.outputs.webapp-url }}
+
+    steps:
+      - name: Download artifact from build job
+        uses: actions/download-artifact@v3
+        with:
+          name: .net-app
+
+      - name: Deploy to Azure Web App
+        id: deploy-to-webapp
+        uses: azure/webapps-deploy@v2
+        with:
+          app-name: 'shopping-assistant-api-dev'
+          slot-name: 'Production'
+          publish-profile: ${{ secrets.AZUREAPPSERVICE_PUBLISHPROFILE_E1A733523AF642D8B37F28AA91718E8C }}
+          package: .

.gitignore

@@ -266,6 +266,9 @@ ServiceFabricBackup/
 *.ldf
 *.ndf
 
+# appsettings.Development.json file (ignore it)
+appsettings.Development.json
+
 # Business Intelligence projects
 *.rdl.data
 *.bim.layout

.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            "program": "${workspaceFolder}/ShoppingAssistantApi.Api/bin/Debug/net7.0/ShoppingAssistantApi.Api.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/ShoppingAssistantApi.Api",
+            "stopAtEntry": false,
+            "serverReadyAction": {
+                "action": "openExternally",
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            }
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "files.exclude": {
+        "**/bin": true
+    },
+    "editor.formatOnType": true
+}

.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

ShoppingAssistantApi.Api/ApiExtentions/GlobalUserExtention.cs

@@ -0,0 +1,12 @@
+using ShoppingAssistantApi.Api.CustomMiddlewares;
+
+namespace ShoppingAssistantApi.Api.ApiExtentions;
+
+public static class GlobalUserExtention
+{
+    public static IApplicationBuilder AddGlobalUserMiddleware(this IApplicationBuilder app)
+    {
+        app.UseMiddleware<GlobalUserCustomMiddleware>();
+        return app;
+    }
+}

ShoppingAssistantApi.Api/ApiExtentions/GraphQlExtention.cs

@@ -0,0 +1,26 @@
+using ShoppingAssistantApi.Api.Queries;
+using ShoppingAssistantApi.Api.Mutations;
+
+namespace ShoppingAssistantApi.Api.ApiExtentions;
+
+public static class GraphQlExtention
+{
+    public static IServiceCollection AddGraphQl(this IServiceCollection services)
+    {
+        services
+            .AddGraphQLServer()
+            .AddQueryType()
+                .AddTypeExtension<UsersQuery>()
+                .AddTypeExtension<RolesQuery>()
+                .AddTypeExtension<WishlistsQuery>()
+            .AddMutationType()
+                .AddTypeExtension<AccessMutation>()
+                .AddTypeExtension<UsersMutation>()
+                .AddTypeExtension<RolesMutation>()
+                .AddTypeExtension<WishlistsMutation>()
+            .AddAuthorization()
+            .InitializeOnStartup(keepWarm: true);
+
+        return services;
+    }
+}

ShoppingAssistantApi.Api/Controllers/BaseController.cs

@@ -0,0 +1,10 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace ShoppingAssistantApi.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class BaseController : ControllerBase
+{
+    
+}

ShoppingAssistantApi.Api/Controllers/ProductsSearchController.cs

@@ -0,0 +1,51 @@
+using HotChocolate.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Enums;
+
+namespace ShoppingAssistantApi.Api.Controllers;
+
+[Authorize]
+public class ProductsSearchController : BaseController
+{
+    private readonly IProductService _productService;
+
+    private readonly IWishlistsService _wishlistsService;
+
+    public ProductsSearchController(IProductService productService, IWishlistsService wishlistsService)
+    {
+        _productService = productService;
+        _wishlistsService = wishlistsService;
+    }
+    
+    [HttpPost("search/{wishlistId}")]
+    public async Task StreamDataToClient(string wishlistId, [FromBody]MessageCreateDto message, CancellationToken cancellationToken)
+    {
+        var dto = new MessageDto()
+        {
+            Text = message.Text,
+            Role = MessageRoles.User.ToString(),
+        };
+        await _wishlistsService.AddMessageToPersonalWishlistAsync(wishlistId, dto, cancellationToken);
+
+        Response.Headers.Add("Content-Type", "text/event-stream");
+        Response.Headers.Add("Cache-Control", "no-cache");
+        Response.Headers.Add("Connection", "keep-alive");
+        
+        var result = _productService.SearchProductAsync(wishlistId, message, cancellationToken);
+        
+        await foreach (var sse in result)
+        {
+            var chunk = JsonConvert.SerializeObject(sse.Data);
+            
+            var serverSentEvent = $"event: {sse.Event}\ndata: {chunk}\n\n";
+            
+            await Response.WriteAsync(serverSentEvent);
+            await Response.Body.FlushAsync();
+        }
+    }
+    
+}

ShoppingAssistantApi.Api/CustomMiddlewares/GlobalUserCustomMiddleware.cs

@@ -0,0 +1,30 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using System.Security.Claims;
+
+namespace ShoppingAssistantApi.Api.CustomMiddlewares;
+
+public class GlobalUserCustomMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    public GlobalUserCustomMiddleware(RequestDelegate next)
+    {
+        this._next = next;
+    }
+
+    public async Task InvokeAsync(HttpContext httpContext)
+    {
+        if (ObjectId.TryParse(httpContext.User.FindFirst(ClaimTypes.NameIdentifier)?.Value, out ObjectId id))
+        {
+            GlobalUser.Id = id;
+        }
+        GlobalUser.Email = httpContext.User.FindFirst(ClaimTypes.Email)?.Value;
+        GlobalUser.Phone = httpContext.User.FindFirst(ClaimTypes.MobilePhone)?.Value;
+        foreach (var role in httpContext.User.FindAll(ClaimTypes.Role))
+        {
+            GlobalUser.Roles.Add(role.Value);
+        }
+        await this._next(httpContext);
+    }
+}

ShoppingAssistantApi.Api/Mutations/AccessMutation.cs

@@ -0,0 +1,20 @@
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Api.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class AccessMutation
+{
+    public Task<TokensModel> LoginAsync(AccessUserModel login, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.LoginAsync(login, cancellationToken);
+
+    public Task<TokensModel> AccessGuestAsync(AccessGuestModel guest, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.AccessGuestAsync(guest, cancellationToken);
+
+    public Task<TokensModel> RefreshAccessTokenAsync(TokensModel model, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.RefreshAccessTokenAsync(model, cancellationToken);
+}

ShoppingAssistantApi.Api/Mutations/RolesMutation.cs

@@ -0,0 +1,15 @@
+using HotChocolate.Authorization;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+
+namespace ShoppingAssistantApi.Api.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class RolesMutation
+{
+    [Authorize]
+    public Task<RoleDto> AddRole(RoleCreateDto roleDto, CancellationToken cancellationToken,
+        [Service] IRolesService rolesService)
+        => rolesService.AddRoleAsync(roleDto, cancellationToken);
+}

ShoppingAssistantApi.Api/Mutations/UsersMutation.cs

@@ -0,0 +1,30 @@
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Operations;
+using HotChocolate.Authorization;
+
+namespace ShoppingAssistantApi.Api.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class UsersMutation
+{
+    [Authorize]
+    public Task<UpdateUserModel> UpdateUserAsync(UserDto userDto, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.UpdateAsync(userDto, cancellationToken);
+
+    [Authorize]
+    public Task<UserDto> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.UpdateUserByAdminAsync(id, userDto, cancellationToken);
+        
+    [Authorize]
+    public Task<UserDto> AddToRoleAsync(string roleName, string userId, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.AddToRoleAsync(roleName, userId, cancellationToken);
+
+    [Authorize]
+    public Task<UserDto> RemoveFromRoleAsync(string roleName, string userId, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.RemoveFromRoleAsync(roleName, userId, cancellationToken);
+}

ShoppingAssistantApi.Api/Mutations/WishlistsMutation.cs

@@ -0,0 +1,29 @@
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+
+namespace ShoppingAssistantApi.Api.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class WishlistsMutation
+{
+    public Task<WishlistDto> StartPersonalWishlistAsync(WishlistCreateDto dto, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.StartPersonalWishlistAsync(dto, cancellationToken);
+
+    public Task<WishlistDto> GenerateNameForPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.GenerateNameForPersonalWishlistAsync(wishlistId, cancellationToken);
+
+    public Task<MessageDto> AddMessageToPersonalWishlistAsync(string wishlistId, MessageDto dto, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.AddMessageToPersonalWishlistAsync(wishlistId, dto, cancellationToken);
+
+    public Task<ProductDto> AddProductToPersonalWishlistAsync(string wishlistId, ProductCreateDto dto, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.AddProductToPersonalWishlistAsync(wishlistId, dto, cancellationToken);
+
+    public Task<WishlistDto> DeletePersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.DeletePersonalWishlistAsync(wishlistId, cancellationToken);
+}

ShoppingAssistantApi.Api/Program.cs

@@ -0,0 +1,50 @@
+using ShoppingAssistantApi.Application.ApplicationExtentions;
+using ShoppingAssistantApi.Persistance.PersistanceExtentions;
+using ShoppingAssistantApi.Infrastructure.InfrastructureExtentions;
+using ShoppingAssistantApi.Api.ApiExtentions;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+var appConfig = Environment.GetEnvironmentVariable("APP_CONFIG") ?? builder.Configuration.GetConnectionString("AppConfig");
+builder.Configuration.AddAzureAppConfiguration(appConfig);
+
+// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+builder.Services.AddJWTTokenAuthentication(builder.Configuration);
+builder.Services.AddMapper();
+builder.Services.AddInfrastructure();
+builder.Services.AddServices();
+builder.Services.AddHttpClient(builder.Configuration);
+builder.Services.AddGraphQl();
+builder.Services.AddControllers();
+
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+
+app.UseAuthentication();
+app.UseAuthorization();
+app.AddGlobalUserMiddleware();
+
+app.MapGraphQL();
+
+app.MapControllers();
+
+// using var scope = app.Services.CreateScope();
+// var serviceProvider = scope.ServiceProvider;
+// var initializer = new DbInitialaizer(serviceProvider);
+// await initializer.InitialaizeDb(CancellationToken.None);
+
+app.Run();
+
+public partial class Program { }

ShoppingAssistantApi.Api/Properties/launchSettings.json

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

ShoppingAssistantApi.Api/Queries/RolesQuery.cs

@@ -0,0 +1,15 @@
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+using HotChocolate.Authorization;
+
+namespace ShoppingAssistantApi.Api.Queries;
+
+[ExtendObjectType(OperationTypeNames.Query)]
+public class RolesQuery
+{
+    [Authorize]
+    public Task<PagedList<RoleDto>> GetRolesPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken,
+        [Service] IRolesService service)
+        => service.GetRolesPageAsync(pageNumber, pageSize, cancellationToken);
+}

ShoppingAssistantApi.Api/Queries/UsersQuery.cs

@@ -0,0 +1,26 @@
+using HotChocolate.Authorization;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+
+namespace ShoppingAssistantApi.Api.Queries;
+
+[ExtendObjectType(OperationTypeNames.Query)]
+public class UsersQuery
+{
+    [Authorize]
+    public Task<UserDto> GetUserAsync(string id, CancellationToken cancellationToken,
+    [Service] IUsersService usersService)
+    => usersService.GetUserAsync(id, cancellationToken);
+
+    [Authorize]
+    public Task<UserDto> GetCurrentUserAsync(CancellationToken cancellationToken,
+    [Service] IUsersService usersService)
+    => usersService.GetUserAsync(GlobalUser.Id.ToString(), cancellationToken);
+
+    [Authorize]
+    public Task<PagedList<UserDto>> GetUsersPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken,
+    [Service] IUsersService usersService)
+    => usersService.GetUsersPageAsync(pageNumber, pageSize, cancellationToken);
+}

ShoppingAssistantApi.Api/Queries/WishlistsQuery.cs

@@ -0,0 +1,30 @@
+using HotChocolate.Authorization;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+
+namespace ShoppingAssistantApi.Api.Queries;
+
+[ExtendObjectType(OperationTypeNames.Query)]
+public class WishlistsQuery
+{
+    [Authorize]
+    public Task<PagedList<WishlistDto>> GetPersonalWishlistsPageAsync(int pageNumber, int pageSize,
+            CancellationToken cancellationToken, [Service] IWishlistsService wishlistsService)
+        => wishlistsService.GetPersonalWishlistsPageAsync(pageNumber, pageSize, cancellationToken);
+
+    [Authorize]
+    public Task<WishlistDto> GetPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken,
+            [Service] IWishlistsService wishlistsService)
+        => wishlistsService.GetPersonalWishlistAsync(wishlistId, cancellationToken);
+
+    [Authorize]
+    public Task<PagedList<MessageDto>> GetMessagesPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize,
+            CancellationToken cancellationToken, [Service] IWishlistsService wishlistsService)
+        => wishlistsService.GetMessagesPageFromPersonalWishlistAsync(wishlistId, pageNumber, pageSize, cancellationToken);
+
+    [Authorize]
+    public Task<PagedList<ProductDto>> GetProductsPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize,
+            CancellationToken cancellationToken, [Service] IWishlistsService wishlistsService)
+        => wishlistsService.GetProductsPageFromPersonalWishlistAsync(wishlistId, pageNumber, pageSize, cancellationToken);
+}

ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="HotChocolate" Version="13.3.3" />
+    <PackageReference Include="HotChocolate.AspNetCore" Version="13.3.3" />
+    <PackageReference Include="HotChocolate.AspNetCore.Authorization" Version="13.3.3" />
+    <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.5" />
+    <PackageReference Include="Microsoft.Azure.AppConfiguration.AspNetCore" Version="6.1.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ShoppingAssistantApi.Application\ShoppingAssistantApi.Application.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Domain\ShoppingAssistantApi.Domain.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Infrastructure\ShoppingAssistantApi.Infrastructure.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Persistance\ShoppingAssistantApi.Persistance.csproj" />
+  </ItemGroup>
+
+
+</Project>

ShoppingAssistantApi.Api/appsettings.json

@@ -0,0 +1,21 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "MongoDatabaseName": "ShoppingAssistant"
+  },
+  "JsonWebTokenKeys": {
+    "ValidateIssuer": true,
+    "ValidateAudience": true,
+    "ValidateLifetime": true,
+    "ValidateIssuerSigningKey": true
+  },
+  "OpenAi": {
+    "ApiUrl": "https://api.openai.com/v1/chat/completions"
+  }
+}

ShoppingAssistantApi.Application/ApplicationExtensions/MapperExtension.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+using ShoppingAssistantApi.Application.MappingProfiles;
+using System.Reflection;
+
+namespace ShoppingAssistantApi.Application.ApplicationExtentions;
+
+public static class MapperExtension
+{
+    public static IServiceCollection AddMapper(this IServiceCollection services)
+    {
+        services.AddAutoMapper(Assembly.GetAssembly(typeof(UserProfile)));
+
+        return services;
+    }
+}

ShoppingAssistantApi.Application/Exceptions/EntityAlreadyExistsException.cs

@@ -0,0 +1,14 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Application.Exceptions;
+public class EntityAlreadyExistsException<TEntity> : Exception where TEntity : EntityBase
+{
+    public EntityAlreadyExistsException()
+        : base($"\"{typeof(TEntity).Name}\" already exists.") { }
+
+    public EntityAlreadyExistsException(string message, Exception innerException)
+        : base(message, innerException) { }
+
+    public EntityAlreadyExistsException(string paramName, string paramValue)
+        : base($"\"{typeof(TEntity).Name}\" with {paramName}: \"{paramValue}\" already exists.") { }
+}

ShoppingAssistantApi.Application/Exceptions/EntityNotFoundException.cs

@@ -0,0 +1,12 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Application.Exceptions;
+
+public class EntityNotFoundException<TEntity> : Exception where TEntity : EntityBase
+{
+    public EntityNotFoundException()
+        : base($"\"{typeof(TEntity).Name}\" was not found.") { }
+
+    public EntityNotFoundException(string message, Exception innerException)
+        : base(message, innerException) { }
+}

ShoppingAssistantApi.Application/Exceptions/InvalidEmailException.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Exceptions;
+
+public class InvalidEmailException : Exception
+{
+    public InvalidEmailException() { }
+
+    public InvalidEmailException(string email) : base(String.Format($"String {email} can not be an email.")) { }
+}

ShoppingAssistantApi.Application/Exceptions/InvalidPhoneNumberException.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Exceptions;
+
+public class InvalidPhoneNumberException : Exception
+{
+    public InvalidPhoneNumberException() { }
+
+    public InvalidPhoneNumberException(string phone) : base(String.Format($"String {phone} can not be a phone number.")) { }
+}

ShoppingAssistantApi.Application/Exceptions/UnAuthorizedException.cs

@@ -0,0 +1,11 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Application.Exceptions;
+
+public class UnAuthorizedException<TEntity> : Exception where TEntity : EntityBase
+{
+    public UnAuthorizedException() { }
+
+    public UnAuthorizedException(ObjectId id) : base(String.Format($"Access to object {id} of type {typeof(TEntity).Name} denied.")) { }
+}

ShoppingAssistantApi.Application/GlobalInstances/GlobalUser.cs

@@ -0,0 +1,13 @@
+using MongoDB.Bson;
+
+namespace ShoppingAssistantApi.Application.GlobalInstances;
+public static class GlobalUser
+{
+    public static ObjectId? Id { get; set; }
+
+    public static string? Email { get; set; }
+
+    public static string? Phone { get; set; }
+
+    public static List<string>? Roles { get; set; } = new List<string>();
+}

ShoppingAssistantApi.Application/IRepositories/IBaseRepository.cs

@@ -0,0 +1,26 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Common;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IBaseRepository<TEntity> where TEntity : EntityBase
+{
+    Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken);
+
+    Task<TEntity> GetOneAsync(ObjectId id, CancellationToken cancellationToken);
+
+    Task<TEntity> GetOneAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<List<TEntity>> GetPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken);
+
+    Task<List<TEntity>> GetPageAsync(int pageNumber, int pageSize, Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<bool> ExistsAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<int> GetTotalCountAsync();
+
+    Task<int> GetCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<TEntity> DeleteAsync(TEntity entity, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IRepositories/IMessagerepository.cs

@@ -0,0 +1,9 @@
+using System.Linq.Expressions;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IMessagesRepository : IBaseRepository<Message>
+{
+    Task<List<Message>> GetPageStartingFromEndAsync(int pageNumber, int pageSize, Expression<Func<Message, bool>> predicate, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IRepositories/IProductsRepository.cs

@@ -0,0 +1,5 @@
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IProductsRepository : IBaseRepository<Product> { }

ShoppingAssistantApi.Application/IRepositories/IRefreshTokensRepository.cs

@@ -0,0 +1,8 @@
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IRefreshTokensRepository : IBaseRepository<RefreshToken>
+{
+    
+}

ShoppingAssistantApi.Application/IRepositories/IRolesRepository.cs

@@ -0,0 +1,12 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Entities;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IRolesRepository : IBaseRepository<Role>
+{
+    Task<Role> GetRoleAsync(ObjectId id, CancellationToken cancellationToken);
+
+    Task<Role> GetRoleAsync(Expression<Func<Role, bool>> predicate, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IRepositories/IUsersRepository.cs

@@ -0,0 +1,15 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Entities;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IUsersRepository : IBaseRepository<User>
+{
+    Task<User> GetUserAsync(ObjectId id, CancellationToken cancellationToken);
+
+    Task<User> GetUserAsync(Expression<Func<User, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<User> UpdateUserAsync(User user, CancellationToken cancellationToken);
+}
+

ShoppingAssistantApi.Application/IRepositories/IWishlistRepository.cs

@@ -0,0 +1,12 @@
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.IRepositories;
+
+public interface IWishlistsRepository : IBaseRepository<Wishlist>
+{
+    Task<Wishlist> GetWishlistAsync(Expression<Func<Wishlist, bool>> predicate, CancellationToken cancellationToken);
+
+    Task<Wishlist> UpdateWishlistNameAsync(ObjectId id, string name, ObjectId updatedById, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IServices/IOpenAiService.cs

@@ -0,0 +1,13 @@
+using ShoppingAssistantApi.Application.Models.OpenAi;
+
+namespace ShoppingAssistantApi.Application.IServices;
+
+public interface IOpenAiService
+{
+    Task<OpenAiMessage> GetChatCompletion(ChatCompletionRequest chat, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Retrieves a stream of tokens (pieces of words) based on provided chat.
+    /// </summary>
+    IAsyncEnumerable<string> GetChatCompletionStream(ChatCompletionRequest chat, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IServices/IProductService.cs

@@ -0,0 +1,12 @@
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.ProductSearch;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.IServices;
+
+public interface IProductService
+{
+    IAsyncEnumerable<ServerSentEvent> SearchProductAsync(string wishlistId, MessageCreateDto message, CancellationToken cancellationToken);
+    
+}

ShoppingAssistantApi.Application/IServices/IRolesService.cs

@@ -0,0 +1,12 @@
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+
+namespace ShoppingAssistantApi.Application.IServices;
+
+public interface IRolesService
+{
+    Task<RoleDto> AddRoleAsync(RoleCreateDto dto, CancellationToken cancellationToken);
+
+    Task<PagedList<RoleDto>> GetRolesPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IServices/IUsersService.cs

@@ -0,0 +1,15 @@
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+
+namespace ShoppingAssistantApi.Application.IServices;
+
+public interface IUsersService
+{
+    Task AddUserAsync(UserDto dto, CancellationToken cancellationToken);
+
+    Task<PagedList<UserDto>> GetUsersPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken);
+
+    Task<UserDto> GetUserAsync(string id, CancellationToken cancellationToken);
+
+    Task UpdateUserAsync(UserDto dto, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IServices/IWishlistService.cs

@@ -0,0 +1,26 @@
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+
+namespace ShoppingAssistantApi.Application.IServices;
+
+public interface IWishlistsService
+{
+    Task<WishlistDto> StartPersonalWishlistAsync(WishlistCreateDto dto, CancellationToken cancellationToken);
+
+    Task<WishlistDto> GenerateNameForPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken);
+
+    Task<MessageDto> AddMessageToPersonalWishlistAsync(string wishlistId, MessageDto dto, CancellationToken cancellationToken);
+
+    Task<PagedList<WishlistDto>> GetPersonalWishlistsPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken);
+
+    Task<WishlistDto> GetPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken);
+
+    Task<PagedList<MessageDto>> GetMessagesPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize, CancellationToken cancellationToken);
+
+    Task<ProductDto> AddProductToPersonalWishlistAsync(string wishlistId, ProductCreateDto dto, CancellationToken cancellationToken);
+
+    Task<PagedList<ProductDto>> GetProductsPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize, CancellationToken cancellationToken);
+
+    Task<WishlistDto> DeletePersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/IServices/Identity/IPasswordHasher.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.IServices.Identity;
+
+public interface IPasswordHasher
+{
+    string Hash(string password);
+
+    bool Check(string password, string passwordHash);
+}

ShoppingAssistantApi.Application/IServices/Identity/ITokensService.cs

@@ -0,0 +1,12 @@
+using System.Security.Claims;
+
+namespace ShoppingAssistantApi.Application.IServices.Identity;
+
+public interface ITokensService
+{
+    string GenerateAccessToken(IEnumerable<Claim> claims);
+
+    string GenerateRefreshToken();
+
+    ClaimsPrincipal GetPrincipalFromExpiredToken(string token);
+}

ShoppingAssistantApi.Application/IServices/Identity/IUsersManager.cs

@@ -0,0 +1,22 @@
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Identity;
+using ShoppingAssistantApi.Application.Models.Operations;
+
+namespace ShoppingAssistantApi.Application.IServices.Identity;
+
+public interface IUserManager
+{
+    Task<TokensModel> AccessGuestAsync(AccessGuestModel guest, CancellationToken cancellationToken);
+
+    Task<TokensModel> LoginAsync(AccessUserModel login, CancellationToken cancellationToken);
+
+    Task<UserDto> AddToRoleAsync(string roleName, string userId, CancellationToken cancellationToken);
+
+    Task<UserDto> RemoveFromRoleAsync(string roleName, string userId, CancellationToken cancellationToken);
+
+    Task<UpdateUserModel> UpdateAsync(UserDto userDto, CancellationToken cancellationToken);
+
+    Task<UserDto> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken);
+
+    Task<TokensModel> RefreshAccessTokenAsync(TokensModel tokensModel, CancellationToken cancellationToken);
+}

ShoppingAssistantApi.Application/MappingProfiles/MessageProfile.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.MappingProfiles;
+public class MessageProfile : Profile
+{
+    public MessageProfile()
+    {
+        CreateMap<Message, MessageDto>().ReverseMap();
+
+        CreateMap<MessageCreateDto, Message>().ReverseMap();
+    }
+}

ShoppingAssistantApi.Application/MappingProfiles/ProductProfile.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.MappingProfiles;
+public class ProductProfile : Profile
+{
+    public ProductProfile()
+    {
+        CreateMap<Product, ProductDto>().ReverseMap();
+
+        CreateMap<ProductCreateDto, Product>().ReverseMap();
+    }
+}

ShoppingAssistantApi.Application/MappingProfiles/RoleProfile.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.MappingProfiles;
+public class RoleProfile : Profile
+{
+    public RoleProfile()
+    {
+        CreateMap<Role, RoleDto>().ReverseMap();
+
+        CreateMap<RoleCreateDto, Role>().ReverseMap();
+    }
+}

ShoppingAssistantApi.Application/MappingProfiles/UserProfile.cs

@@ -0,0 +1,12 @@
+using AutoMapper;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.MappingProfiles;
+public class UserProfile : Profile
+{
+    public UserProfile()
+    {
+        CreateMap<User, UserDto>().ReverseMap();
+    }
+}

ShoppingAssistantApi.Application/MappingProfiles/WishlistProfile.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Application.MappingProfiles;
+public class WishlistProfile : Profile
+{
+    public WishlistProfile()
+    {
+        CreateMap<Wishlist, WishlistDto>().ReverseMap();
+
+        CreateMap<WishlistCreateDto, Wishlist>().ReverseMap();
+    }
+}

ShoppingAssistantApi.Application/Models/CreateDtos/MessageCreateDto.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.CreateDtos;
+
+public class MessageCreateDto
+{
+    public required string Text { get; set; }
+}

ShoppingAssistantApi.Application/Models/CreateDtos/ProductCreateDto.cs

@@ -0,0 +1,18 @@
+namespace ShoppingAssistantApi.Application.Models.CreateDtos;
+
+public class ProductCreateDto
+{
+    public required string Url { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string Description { get; set; }
+
+    public required double Rating { get; set; }
+    
+    public required double Price { get; set; }
+
+    public required string[] ImagesUrls { get; set; }
+
+    public required bool WasOpened { get; set; }
+}

ShoppingAssistantApi.Application/Models/CreateDtos/RoleCreateDto.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.CreateDtos;
+
+public class RoleCreateDto
+{
+    public string Name { get; set; }
+}

ShoppingAssistantApi.Application/Models/CreateDtos/WishlistCreateDto.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Models.CreateDtos;
+
+public class WishlistCreateDto
+{
+    public required string Type { get; set; }
+
+    public required string FirstMessageText { get; set; }
+}

ShoppingAssistantApi.Application/Models/Dtos/MessageDto.cs

@@ -0,0 +1,12 @@
+namespace ShoppingAssistantApi.Application.Models.Dtos;
+
+public class MessageDto
+{
+    public string Id { get; set; }
+
+    public string Text { get; set; }
+
+    public string Role { get; set; }
+
+    public string CreatedById { get; set; }
+}

ShoppingAssistantApi.Application/Models/Dtos/ProductDto.cs

@@ -0,0 +1,22 @@
+namespace ShoppingAssistantApi.Application.Models.Dtos;
+
+public class ProductDto
+{
+    public required string Id { get; set; }
+
+    public required string Url { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string Description { get; set; }
+
+    public required double Rating { get; set; }
+
+    public required double Price { get; set; }
+    
+    public required string[] ImagesUrls { get; set; }
+
+    public required bool WasOpened { get; set; }
+
+    public required string WishlistId { get; set; }
+}

ShoppingAssistantApi.Application/Models/Dtos/RoleDto.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Models.Dtos;
+
+public class RoleDto
+{
+    public string Id { get; set; }
+
+    public string Name { get; set; }
+}

ShoppingAssistantApi.Application/Models/Dtos/UserDto.cs

@@ -0,0 +1,20 @@
+ namespace ShoppingAssistantApi.Application.Models.Dtos;
+
+public class UserDto
+{
+    public string Id { get; set; }
+
+    public Guid? GuestId { get; set; }
+
+    public List<RoleDto> Roles { get; set; }
+
+    public string? Phone { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? Password { get; set; }
+
+    public string? RefreshToken { get; set; }
+
+    public DateTime? RefreshTokenExpiryDate { get; set; }
+}

ShoppingAssistantApi.Application/Models/Dtos/WishlistDto.cs

@@ -0,0 +1,12 @@
+namespace ShoppingAssistantApi.Application.Models.Dtos;
+
+public class WishlistDto
+{
+    public required string Id { get; set; }
+
+    public required string Name { get; set; }
+
+    public required string Type { get; set; }
+
+    public required string CreatedById { get; set; }
+}

ShoppingAssistantApi.Application/Models/Identity/AccessGuestModel.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.Identity;
+
+public class AccessGuestModel
+{
+    public Guid GuestId { get; set; }
+}

ShoppingAssistantApi.Application/Models/Identity/AccessUserModel.cs

@@ -0,0 +1,10 @@
+namespace ShoppingAssistantApi.Application.Models.Identity;
+
+public class AccessUserModel
+{
+    public string? Email { get; set; }
+
+    public string? Phone { get; set; }
+
+    public string Password { get; set; }
+}

ShoppingAssistantApi.Application/Models/Identity/TokensModel.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Models.Identity;
+
+public class TokensModel
+{
+    public string AccessToken { get; set; }
+
+    public string RefreshToken { get; set; }
+}

ShoppingAssistantApi.Application/Models/OpenAi/ChatCompletionRequest.cs

@@ -0,0 +1,14 @@
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class ChatCompletionRequest
+{
+    public string Model { get; set; } = "gpt-4-1106-preview";
+
+    public List<OpenAiMessage> Messages { get; set; }
+
+    public double Temperature { get; set; } = 0.7;
+
+    public int MaxTokens { get; set; } = 256;
+
+    public bool Stream { get; set; } = false;
+}

ShoppingAssistantApi.Application/Models/OpenAi/OpenAiChoice.cs

@@ -0,0 +1,12 @@
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class OpenAiChoice
+{
+    public OpenAiMessage Message { get; set; }
+    
+    public OpenAiDelta Delta { get; set; }
+
+    public string FinishReason { get; set; }
+    
+    public int Index { get; set; }
+}

ShoppingAssistantApi.Application/Models/OpenAi/OpenAiDelta.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class OpenAiDelta
+{
+    public string Role { get; set; }
+
+    public string Content { get; set; }
+}

ShoppingAssistantApi.Application/Models/OpenAi/OpenAiMessage.cs

@@ -0,0 +1,10 @@
+using ShoppingAssistantApi.Domain.Enums;
+
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class OpenAiMessage
+{
+    public string Role { get; set; }
+
+    public string Content { get; set; }
+}

ShoppingAssistantApi.Application/Models/OpenAi/OpenAiResponse.cs

@@ -0,0 +1,16 @@
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class OpenAiResponse
+{
+    public string Id { get; set; }
+
+    public string Object { get; set; }
+
+    public int Created { get; set; }
+
+    public string Model { get; set; }
+
+    public OpenAiUsage Usage { get; set; }
+
+    public List<OpenAiChoice> Choices { get; set; }
+}

ShoppingAssistantApi.Application/Models/OpenAi/OpenAiUsage.cs

@@ -0,0 +1,10 @@
+namespace ShoppingAssistantApi.Application.Models.OpenAi;
+
+public class OpenAiUsage
+{
+    public int PromptTokens { get; set; }
+
+    public int CompletionTokens { get; set; }
+
+    public int TotalTokens { get; set; }
+}

ShoppingAssistantApi.Application/Models/Operations/UpdateUserModel.cs

@@ -0,0 +1,11 @@
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Application.Models.Operations;
+
+public class UpdateUserModel
+{
+    public TokensModel Tokens { get; set; }
+
+    public UserDto User { get; set; }
+}

ShoppingAssistantApi.Application/Models/ProductSearch/MessagePart.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.ProductSearch;
+
+public class MessagePart
+{
+    public string Text { get; set; }
+}

ShoppingAssistantApi.Application/Models/ProductSearch/ProductName.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.ProductSearch;
+
+public class ProductName
+{
+    public string Name { get; set; }
+}

ShoppingAssistantApi.Application/Models/ProductSearch/Question.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.ProductSearch;
+
+public class Question
+{
+    public string QuestionText { get; set; }
+}

ShoppingAssistantApi.Application/Models/ProductSearch/ServerSentEvent.cs

@@ -0,0 +1,10 @@
+using ShoppingAssistantApi.Domain.Enums;
+
+namespace ShoppingAssistantApi.Application.Models.ProductSearch;
+
+public class ServerSentEvent
+{
+    public SearchEventType Event { get; set; }
+
+    public string Data { get; set; }
+}

ShoppingAssistantApi.Application/Models/ProductSearch/Suggestion.cs

@@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.ProductSearch;
+
+public class Suggestion
+{
+    public string Text { get; set; }
+}

ShoppingAssistantApi.Application/Paging/PageParameters.cs

@@ -0,0 +1,8 @@
+namespace ShoppingAssistantApi.Application.Paging;
+
+public class PageParameters
+{
+    public int PageSize { get; set; }
+
+    public int PageNumber { get; set; }
+}

ShoppingAssistantApi.Application/Paging/PagedList.cs

@@ -0,0 +1,30 @@
+namespace ShoppingAssistantApi.Application.Paging;
+
+public class PagedList<T>
+{
+    public IEnumerable<T> Items { get; set; }
+
+    public int PageNumber { get; set; }
+
+    public int PageSize { get; set; }
+
+    public int TotalPages { get; set; }
+
+    public int TotalItems { get; set; }
+
+    public bool HasPreviousPage => PageNumber > 1;
+
+    public bool HasNextPage => PageNumber < TotalPages;
+
+    public PagedList() { }
+
+    public PagedList(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems)
+    {
+        this.PageNumber = pageNumber;
+        this.PageSize = pageSize;
+        this.TotalItems = totalItems;
+        this.TotalPages = (int)Math.Ceiling(totalItems / (double)pageSize);
+
+        this.Items = items;
+    }
+}

ShoppingAssistantApi.Application/ShoppingAssistantApi.Application.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="12.0.1" />
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ShoppingAssistantApi.Domain\ShoppingAssistantApi.Domain.csproj" />
+  </ItemGroup>
+
+
+</Project>

ShoppingAssistantApi.Domain/Common/EntityBase.cs

@@ -0,0 +1,20 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace ShoppingAssistantApi.Domain.Common;
+
+public abstract class EntityBase
+{
+    [BsonId]
+    public ObjectId Id { get; set; }
+
+    public ObjectId CreatedById { get; set; }
+
+    public DateTime CreatedDateUtc { get; set; }
+
+    public bool IsDeleted { get; set; }
+
+    public ObjectId? LastModifiedById { get; set; }
+
+    public DateTime? LastModifiedDateUtc { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/Message.cs

@@ -0,0 +1,13 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class Message : EntityBase
+{
+    public string Text { get; set; }
+
+    public string Role { get; set; }
+
+    public ObjectId WishlistId { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/Product.cs

@@ -0,0 +1,24 @@
+using MongoDB.Bson;
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class Product : EntityBase
+{
+
+    public string Url { get; set; }
+
+    public string Name { get; set; }
+
+    public string Description { get; set; }
+
+    public double Rating { get; set; }
+
+    public string[] ImagesUrls { get; set; }
+
+    public bool WasOpened { get; set; }
+    
+    public double Price { get; set; }
+
+    public ObjectId WishlistId { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/RefreshToken.cs

@@ -0,0 +1,10 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class RefreshToken : EntityBase
+{
+    public string Token { get; set; }
+
+    public DateTime ExpiryDateUTC { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/Role.cs

@@ -0,0 +1,8 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class Role : EntityBase
+{
+    public string Name { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/User.cs

@@ -0,0 +1,16 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class User : EntityBase
+{
+    public Guid GuestId { get; set; }
+
+    public List<Role> Roles { get; set; }
+
+    public string? Phone { get; set; }
+
+    public string? Email { get; set; }
+
+    public string? PasswordHash { get; set; }
+}

ShoppingAssistantApi.Domain/Entities/Wishlist.cs

@@ -0,0 +1,10 @@
+using ShoppingAssistantApi.Domain.Common;
+
+namespace ShoppingAssistantApi.Domain.Entities;
+
+public class Wishlist : EntityBase
+{
+    public string Name { get; set; }
+
+    public string Type { get; set; }
+}

ShoppingAssistantApi.Domain/Enums/MessageRoles.cs

@@ -0,0 +1,7 @@
+namespace ShoppingAssistantApi.Domain.Enums;
+
+public enum MessageRoles
+{
+    User = 0,
+    Application = 1
+}

ShoppingAssistantApi.Domain/Enums/OpenAiRole.cs

@@ -0,0 +1,26 @@
+namespace ShoppingAssistantApi.Domain.Enums;
+
+public enum OpenAiRole
+{
+    System,
+    User,
+    Assistant
+}
+
+public static class OpenAiRoleExtensions
+{
+    public static string RequestConvert(this OpenAiRole role)
+    {
+        switch (role)
+        {
+            case OpenAiRole.System:
+                return "system";
+            case OpenAiRole.Assistant:
+                return "assistant";
+            case OpenAiRole.User:
+                return "user";
+            default:
+                return "";
+        }
+    }
+}

ShoppingAssistantApi.Domain/Enums/SearchEventType.cs

@@ -0,0 +1,24 @@
+namespace ShoppingAssistantApi.Domain.Enums;
+
+public enum SearchEventType
+{
+    Wishlist = 0,
+    Message = 1,
+    Suggestion = 2,
+    Product = 3
+}
+
+public static class SearchEventTypeExtensions
+{
+    public static string ToSseEventString(this SearchEventType eventType)
+    {
+        return eventType switch
+        {
+            SearchEventType.Wishlist => "wishlist",
+            SearchEventType.Message => "message",
+            SearchEventType.Suggestion => "suggestion",
+            SearchEventType.Product => "product",
+            _ => throw new ArgumentOutOfRangeException(nameof(eventType), eventType, null),
+        };
+    }
+}

ShoppingAssistantApi.Domain/Enums/WishlistTypes.cs

@@ -0,0 +1,7 @@
+namespace ShoppingAssistantApi.Domain.Enums;
+
+public enum WishlistTypes
+{
+    Product = 0,
+    Gift = 1
+}

ShoppingAssistantApi.Domain/ShoppingAssistantApi.Domain.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MongoDB.Bson" Version="2.20.0" />
+  </ItemGroup>
+
+</Project>

ShoppingAssistantApi.Infrastructure/InfrastructureExtentions/JwtTokenAuthenticationExtention.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
+using System.Text;
+
+namespace ShoppingAssistantApi.Infrastructure.InfrastructureExtentions;
+
+public static class JwtTokenAuthenticationExtention
+{
+    public static IServiceCollection AddJWTTokenAuthentication(this IServiceCollection services,
+                                                     IConfiguration configuration)
+    {
+        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+        .AddJwtBearer(options =>
+        {
+            options.TokenValidationParameters = new TokenValidationParameters
+            {
+                ValidateIssuer = configuration.GetValue<bool>("JsonWebTokenKeys:ValidateIssuer"),
+                ValidateAudience = configuration.GetValue<bool>("JsonWebTokenKeys:ValidateAudience"),
+                ValidateLifetime = configuration.GetValue<bool>("JsonWebTokenKeys:ValidateLifetime"),
+                ValidateIssuerSigningKey = configuration.GetValue<bool>("JsonWebTokenKeys:ValidateIssuerSigningKey"),
+                ValidIssuer = configuration.GetValue<string>("JsonWebTokenKeys:ValidIssuer"),
+                ValidAudience = configuration.GetValue<string>("JsonWebTokenKeys:ValidAudience"),
+                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration.GetValue<string>("JsonWebTokenKeys:IssuerSigningKey"))),
+                ClockSkew = TimeSpan.Zero
+            };
+        });
+
+        return services;
+    }
+}

ShoppingAssistantApi.Infrastructure/InfrastructureExtentions/ServicesExtention.cs

@@ -0,0 +1,39 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Infrastructure.Services;
+using ShoppingAssistantApi.Infrastructure.Services.Identity;
+using System.Net.Http.Headers;
+
+namespace ShoppingAssistantApi.Infrastructure.InfrastructureExtentions;
+public static class ServicesExtention
+{
+    public static IServiceCollection AddServices(this IServiceCollection services)
+    {
+        services.AddScoped<IRolesService, RolesService>();
+        services.AddScoped<IPasswordHasher, PasswordHasher>();
+        services.AddScoped<IUserManager, UserManager>();
+        services.AddScoped<ITokensService, TokensService>();
+        services.AddScoped<IUsersService, UsersService>();
+        services.AddScoped<IWishlistsService, WishlistsService>();
+        services.AddScoped<IOpenAiService, OpenAiService>();
+        services.AddScoped<IProductService, ProductService>();
+
+        return services;
+    }
+
+    public static IServiceCollection AddHttpClient(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddHttpClient(
+            "OpenAiHttpClient",
+            client =>
+            {
+                client.BaseAddress = new Uri(configuration.GetValue<string>("OpenAi:ApiUrl"));
+                client.DefaultRequestHeaders.Authorization = 
+                    new AuthenticationHeaderValue("Bearer", configuration.GetValue<string>("OpenAi:ApiKey"));
+            });
+
+        return services;
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/Identity/PasswordHasher.cs

@@ -0,0 +1,55 @@
+using Microsoft.Extensions.Logging;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using System.Security.Cryptography;
+
+namespace ShoppingAssistantApi.Infrastructure.Services.Identity;
+public class PasswordHasher : IPasswordHasher
+{
+    private const int SaltSize = 16;
+
+    private const int KeySize = 32;
+
+    private readonly int _iterations;
+
+    private readonly ILogger _logger;
+
+    public PasswordHasher(ILogger<PasswordHasher> logger)
+    {
+        var random = new Random();
+        this._iterations = random.Next(100, 1000);
+        this._logger = logger;
+    }
+
+    public string Hash(string password)
+    {
+        using (var algorithm = new Rfc2898DeriveBytes(password, SaltSize, _iterations,
+                                                      HashAlgorithmName.SHA256))
+        {
+            var key = Convert.ToBase64String(algorithm.GetBytes(KeySize));
+            var salt = Convert.ToBase64String(algorithm.Salt);
+
+            this._logger.LogInformation($"Hashed password.");
+
+            return $"{this._iterations}.{salt}.{key}";
+        }
+    }
+
+    public bool Check(string password, string passwordHash)
+    {
+        var parts = passwordHash.Split(".", 3);
+
+        var iterations = Convert.ToInt32(parts[0]);
+        var salt = Convert.FromBase64String(parts[1]);
+        var userKey = parts[2];
+
+        using (var algorithm = new Rfc2898DeriveBytes(password, salt, iterations,
+                                                      HashAlgorithmName.SHA256))
+        {
+            var key = Convert.ToBase64String(algorithm.GetBytes(KeySize));
+
+            this._logger.LogInformation($"Checked password.");
+
+            return key == userKey;
+        }
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/Identity/TokensService.cs

@@ -0,0 +1,87 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.IdentityModel.Tokens;
+using ShoppingAssistantApi.Application.IServices.Identity;
+
+namespace ShoppingAssistantApi.Infrastructure.Services.Identity;
+
+public class TokensService : ITokensService
+{
+    private readonly IConfiguration _configuration;
+
+    private readonly ILogger _logger;
+
+    public TokensService(
+        IConfiguration configuration, 
+        ILogger<TokensService> logger)
+    {
+        this._configuration = configuration;
+        this._logger = logger;
+    }
+
+    public string GenerateAccessToken(IEnumerable<Claim> claims)
+    {
+        var tokenOptions = GetTokenOptions(claims);
+        var tokenString = new JwtSecurityTokenHandler().WriteToken(tokenOptions);
+
+        this._logger.LogInformation($"Generated new access token.");
+
+        return tokenString;
+    }
+
+    public string GenerateRefreshToken()
+    {
+        var randomNumber = new byte[32];
+        using var rng = RandomNumberGenerator.Create();
+        rng.GetBytes(randomNumber);
+        var refreshToken = Convert.ToBase64String(randomNumber);
+
+        this._logger.LogInformation($"Generated new refresh token.");
+
+        return refreshToken;
+    }
+
+    public ClaimsPrincipal GetPrincipalFromExpiredToken(string token)
+    {
+        var tokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateAudience = false,
+            ValidateIssuer = false,
+            ValidateIssuerSigningKey = true,
+            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(
+                _configuration.GetValue<string>("JsonWebTokenKeys:IssuerSigningKey"))),
+            ValidateLifetime = false
+        };
+        var tokenHandler = new JwtSecurityTokenHandler();
+        var principal = tokenHandler.ValidateToken(token, tokenValidationParameters, out var securityToken);
+        var jwtSecurityToken = securityToken as JwtSecurityToken;
+        if (jwtSecurityToken == null 
+            || !jwtSecurityToken.Header.Alg.Equals(SecurityAlgorithms.HmacSha256, StringComparison.InvariantCultureIgnoreCase))
+            throw new SecurityTokenException("Invalid token");
+
+        this._logger.LogInformation($"Returned data from expired access token.");
+
+        return principal;
+    }
+
+    private JwtSecurityToken GetTokenOptions(IEnumerable<Claim> claims)
+    {
+        var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(
+            _configuration.GetValue<string>("JsonWebTokenKeys:IssuerSigningKey")));
+        var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);
+
+        var tokenOptions = new JwtSecurityToken(
+            issuer: _configuration.GetValue<string>("JsonWebTokenKeys:ValidIssuer"),
+            audience: _configuration.GetValue<string>("JsonWebTokenKeys:ValidAudience"),
+            expires: DateTime.UtcNow.AddMinutes(15),
+            claims: claims,
+            signingCredentials: signinCredentials
+        );
+
+        return tokenOptions;
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/Identity/UserManager.cs

@@ -0,0 +1,365 @@
+using AutoMapper;
+using Microsoft.Extensions.Logging;
+using Microsoft.IdentityModel.Tokens;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.Exceptions;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Identity;
+using ShoppingAssistantApi.Application.Models.Operations;
+using ShoppingAssistantApi.Domain.Entities;
+using System.Security.Claims;
+using System.Text.RegularExpressions;
+
+namespace ShoppingAssistantApi.Infrastructure.Services.Identity;
+
+public class UserManager : ServiceBase, IUserManager
+{
+    private readonly IUsersRepository _usersRepository;
+
+    private readonly IPasswordHasher _passwordHasher;
+
+    private readonly ITokensService _tokensService;
+
+    private readonly IRolesRepository _rolesRepository;
+    
+    private readonly IRefreshTokensRepository _refreshTokensRepository;
+
+    private readonly IMapper _mapper;
+
+    private readonly ILogger _logger;
+
+    public UserManager(
+        IUsersRepository usersRepository, 
+        IPasswordHasher passwordHasher, 
+        ITokensService tokensService, 
+        IRolesRepository rolesRepository,
+        IRefreshTokensRepository refreshTokensRepository,
+        IMapper mapper, 
+        ILogger<UserManager> logger)
+    {
+        this._usersRepository = usersRepository;
+        this._logger = logger;
+        this._passwordHasher = passwordHasher;
+        this._tokensService = tokensService;
+        this._mapper = mapper;
+        this._rolesRepository = rolesRepository;
+        this._refreshTokensRepository = refreshTokensRepository;
+    }
+
+    public async Task<TokensModel> LoginAsync(AccessUserModel login, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Logging in user with email: {login.Email} and phone: {login.Phone}.");
+
+        var user = string.IsNullOrEmpty(login.Phone)
+            ? await this._usersRepository.GetUserAsync(u => u.Email == login.Email, cancellationToken)
+            : await this._usersRepository.GetUserAsync(u => u.Phone == login.Phone, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        if (!this._passwordHasher.Check(login.Password, user.PasswordHash))
+        {
+            throw new InvalidDataException("Invalid password!");
+        }
+
+        var refreshToken = await AddRefreshToken(user.Id, cancellationToken);
+
+        var tokens = this.GetUserTokens(user, refreshToken);
+
+        this._logger.LogInformation($"Logged in user with email: {login.Email} and phone: {login.Phone}.");
+
+        return tokens;
+    }
+
+    public async Task<TokensModel> AccessGuestAsync(AccessGuestModel guest, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Logging in / Registering guest with guest id: {guest.GuestId}.");
+
+        var user = await this._usersRepository.GetUserAsync(x => x.GuestId == guest.GuestId, cancellationToken);
+
+        if (user == null)
+        {
+            var role = await this._rolesRepository.GetRoleAsync(r => r.Name == "Guest", cancellationToken);
+            user = new User
+            {
+                GuestId = guest.GuestId,
+                Roles = new List<Role> { role },
+                CreatedDateUtc = DateTime.UtcNow,
+                CreatedById = ObjectId.Empty // Default value for all new users
+            };
+
+            await this._usersRepository.AddAsync(user, cancellationToken);
+
+            this._logger.LogInformation($"Created guest with guest id: {guest.GuestId}.");
+        }
+
+        var refreshToken = await AddRefreshToken(user.Id, cancellationToken);
+        var tokens = this.GetUserTokens(user, refreshToken);
+
+        this._logger.LogInformation($"Logged in guest with guest id: {guest.GuestId}.");
+
+        return tokens;
+    }
+
+    public async Task<TokensModel> RefreshAccessTokenAsync(TokensModel tokensModel, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Refreshing access token.");
+
+        var principal = _tokensService.GetPrincipalFromExpiredToken(tokensModel.AccessToken);
+        var userId = ParseObjectId(principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value);
+
+        var refreshTokenModel = await this._refreshTokensRepository
+            .GetOneAsync(r => 
+                r.Token == tokensModel.RefreshToken 
+                && r.CreatedById == userId
+                , cancellationToken);
+        if (refreshTokenModel == null || refreshTokenModel.ExpiryDateUTC < DateTime.UtcNow)
+        {
+            throw new SecurityTokenExpiredException();
+        }
+
+        var refreshToken = refreshTokenModel.Token;
+
+        // Update Refresh token if it expires in less than 7 days to keep user constantly logged in if he uses the app
+        if (refreshTokenModel.ExpiryDateUTC.AddDays(-7) < DateTime.UtcNow)
+        {
+            await _refreshTokensRepository.DeleteAsync(refreshTokenModel, cancellationToken);
+            
+            var newRefreshToken = await AddRefreshToken(userId, cancellationToken);
+            refreshToken = newRefreshToken.Token;
+        }
+
+        var tokens = new TokensModel
+        {
+            AccessToken = _tokensService.GenerateAccessToken(principal.Claims),
+            RefreshToken = refreshToken
+        };
+
+        this._logger.LogInformation($"Refreshed access token.");
+
+        return tokens;
+    }
+
+    public async Task<UserDto> AddToRoleAsync(string roleName, string userId, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Adding Role: {roleName} to User with Id: {userId}.");
+
+        var role = await this._rolesRepository.GetRoleAsync(r => r.Name == roleName, cancellationToken);
+        if (role == null)
+        {
+            throw new EntityNotFoundException<Role>();
+        }
+
+        var userObjectId = ParseObjectId(userId);
+        var user = await this._usersRepository.GetUserAsync(userObjectId, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        user.Roles.Add(role);
+        var updatedUser = await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+        var userDto = this._mapper.Map<UserDto>(updatedUser);
+
+        this._logger.LogInformation($"Added Role: {roleName} to User with Id: {userId}.");
+
+        return userDto;
+    }
+
+    public async Task<UserDto> RemoveFromRoleAsync(string roleName, string userId, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Removing Role: {roleName} from User with Id: {userId}.");
+
+        var role = await this._rolesRepository.GetRoleAsync(r => r.Name == roleName, cancellationToken);
+        if (role == null)
+        {
+            throw new EntityNotFoundException<Role>();
+        }
+
+        var userObjectId = ParseObjectId(userId);
+        var user = await this._usersRepository.GetUserAsync(userObjectId, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        var deletedRole = user.Roles.Find(x => x.Name == role.Name);
+        user.Roles.Remove(deletedRole);
+
+        var updatedUser = await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+        var userDto = this._mapper.Map<UserDto>(updatedUser);
+
+        this._logger.LogInformation($"Removed Role: {roleName} from User with Id: {userId}.");
+
+        return userDto;
+    }
+
+    public async Task<UpdateUserModel> UpdateAsync(UserDto userDto, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Updating user with id: {GlobalUser.Id}.");
+
+        var user = await this._usersRepository.GetUserAsync(x => x.Id == GlobalUser.Id, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        await ValidateUserAsync(userDto, user, cancellationToken);   
+
+        this._mapper.Map(userDto, user);
+        if (!string.IsNullOrEmpty(userDto.Password))
+        {
+            user.PasswordHash = this._passwordHasher.Hash(userDto.Password);
+        }
+        await CheckAndUpgradeToUserAsync(user, cancellationToken);
+
+        var updatedUser = await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+
+        var refreshToken = await AddRefreshToken(user.Id, cancellationToken);
+        var tokens = this.GetUserTokens(user, refreshToken);
+
+        var updatedUserDto = this._mapper.Map<UserDto>(updatedUser);
+
+        this._logger.LogInformation($"Update user with id: {GlobalUser.Id}.");
+
+        return new UpdateUserModel() 
+        { 
+            Tokens = tokens, 
+            User = updatedUserDto
+        };
+    }
+
+    public async Task<UserDto> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Admin updating User with Id: {id}.");
+
+        var userObjectId = ParseObjectId(id);
+        var user = await this._usersRepository.GetUserAsync(userObjectId, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        await ValidateUserAsync(userDto, user, cancellationToken);   
+
+        this._mapper.Map(userDto, user);
+        var updatedUser = await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+
+        var updatedUserDto = this._mapper.Map<UserDto>(updatedUser);
+        
+        this._logger.LogInformation($"Admin updated User with Id: {id}.");
+
+        return updatedUserDto;
+    }
+
+    private async Task<RefreshToken> AddRefreshToken(ObjectId userId, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation($"Adding new refresh token for user with Id : {userId}.");
+
+        var refreshToken = new RefreshToken
+        {
+            Token = _tokensService.GenerateRefreshToken(),
+            ExpiryDateUTC = DateTime.UtcNow.AddDays(30),
+            CreatedById = userId,
+            CreatedDateUtc = DateTime.UtcNow
+        };
+
+        await this._refreshTokensRepository.AddAsync(refreshToken, cancellationToken);
+
+        this._logger.LogInformation($"Added new refresh token.");
+
+        return refreshToken;
+    }
+
+    private TokensModel GetUserTokens(User user, RefreshToken refreshToken)
+    {
+        var claims = this.GetClaims(user);
+        var accessToken = this._tokensService.GenerateAccessToken(claims);
+
+        this._logger.LogInformation($"Returned new access and refresh tokens.");
+
+        return new TokensModel
+        {
+            AccessToken = accessToken,
+            RefreshToken = refreshToken.Token,
+        };
+    }
+
+    private IEnumerable<Claim> GetClaims(User user)
+    {
+        var claims = new List<Claim>()
+            {
+                new (ClaimTypes.NameIdentifier, user.Id.ToString()),
+                new (ClaimTypes.Email, user.Email ?? string.Empty),
+                new (ClaimTypes.MobilePhone, user.Phone ?? string.Empty),
+            };
+
+        foreach (var role in user.Roles)
+        {
+            claims.Add(new (ClaimTypes.Role, role.Name));
+        }
+
+        this._logger.LogInformation($"Returned claims for User with Id: {user.Id}.");
+
+        return claims;
+    }
+
+    private async Task CheckAndUpgradeToUserAsync(User user, CancellationToken cancellationToken)
+    {
+        if (user.Roles.Any(x => x.Name == "Guest" && x.IsDeleted == false) && !user.Roles.Any(x => x.Name == "User" && x.IsDeleted == false))
+        {
+            if (!string.IsNullOrEmpty(user.PasswordHash) && (!string.IsNullOrEmpty(user.Email) || !string.IsNullOrEmpty(user.Phone)))
+            {
+                var role = await this._rolesRepository.GetRoleAsync(x => x.Name == "User", cancellationToken);
+                user.Roles.Add(role);
+            }
+        }
+    }
+
+    private async Task ValidateUserAsync(UserDto userDto, User user, CancellationToken cancellationToken)
+    {
+        if (!string.IsNullOrEmpty(userDto.Email)) 
+        {
+            ValidateEmail(userDto.Email);
+            if (userDto.Email != user.Email 
+                && await this._usersRepository.ExistsAsync(x => x.Email == userDto.Email, cancellationToken))
+            {
+                throw new EntityAlreadyExistsException<User>("email", userDto.Email);
+            }
+        }
+
+        if (!string.IsNullOrEmpty(userDto.Phone)) 
+        {
+            ValidatePhone(userDto.Phone);
+            if (userDto.Phone != user.Phone 
+                && await this._usersRepository.ExistsAsync(x => x.Phone == userDto.Phone, cancellationToken))
+            {
+                throw new EntityAlreadyExistsException<User>("phone", userDto.Phone);
+            }
+        }
+    }
+
+    private void ValidateEmail(string email)
+    {
+        string regex = @"^[^@\s]+@[^@\s]+\.[^@\s]+$";
+
+        if (!Regex.IsMatch(email, regex))
+        {
+            throw new InvalidEmailException(email);
+        }
+    }
+
+    private void ValidatePhone(string phone)
+    {
+        string regex = @"^\+[0-9]{1,15}$";
+
+        if (!Regex.IsMatch(phone, regex))
+        {
+            throw new InvalidPhoneNumberException(phone);
+        }
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/OpenAiService.cs

@@ -0,0 +1,71 @@
+using System.IO;
+using System.Net.Http.Headers;
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.OpenAi;
+
+namespace ShoppingAssistantApi.Infrastructure.Services;
+
+public class OpenAiService : IOpenAiService
+{
+
+    private readonly JsonSerializerSettings _jsonSettings = new JsonSerializerSettings
+    {
+        ContractResolver = new DefaultContractResolver
+        {
+            NamingStrategy = new SnakeCaseNamingStrategy()
+        },
+        NullValueHandling = NullValueHandling.Ignore,
+    };
+
+    private readonly HttpClient _httpClient;
+
+    public OpenAiService(IHttpClientFactory httpClientFactory)
+    {
+        _httpClient = httpClientFactory.CreateClient("OpenAiHttpClient");
+    }
+
+    public async Task<OpenAiMessage> GetChatCompletion(ChatCompletionRequest chat, CancellationToken cancellationToken)
+    {
+        chat.Stream = false; 
+        var jsonBody = JsonConvert.SerializeObject(chat, _jsonSettings);
+        var body = new StringContent(jsonBody, Encoding.UTF8, "application/json");
+
+        using var httpResponse = await _httpClient.PostAsync("", body, cancellationToken);
+
+        var responseBody = await httpResponse.Content.ReadAsStringAsync(cancellationToken);
+
+        var data = JsonConvert.DeserializeObject<OpenAiResponse>(responseBody);
+
+        return data.Choices[0].Message;
+    }
+
+    public async IAsyncEnumerable<string> GetChatCompletionStream(ChatCompletionRequest chat, CancellationToken cancellationToken)
+    {
+        chat.Stream = true;
+        var jsonBody = JsonConvert.SerializeObject(chat, _jsonSettings);
+        
+        var body = new StringContent(jsonBody, Encoding.UTF8, "application/json");
+
+        using var httpResponse = await _httpClient.PostAsync("", body, cancellationToken);
+
+        using var responseStream = await httpResponse.Content.ReadAsStreamAsync(cancellationToken);
+        using var reader = new StreamReader(responseStream, Encoding.UTF8);
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            var jsonChunk = await reader.ReadLineAsync();
+            if (jsonChunk.StartsWith("data: "))
+            {
+                jsonChunk = jsonChunk.Substring("data: ".Length);
+                if (jsonChunk == "[DONE]") break;
+                var data = JsonConvert.DeserializeObject<OpenAiResponse>(jsonChunk);
+                if (data.Choices[0].Delta.Content == "" || data.Choices[0].Delta.Content == null) continue;
+                yield return data.Choices[0].Delta.Content;
+            }
+        }
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/ProductService.cs

@@ -0,0 +1,217 @@
+using System.Diagnostics;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.OpenAi;
+using ShoppingAssistantApi.Application.Models.ProductSearch;
+using ShoppingAssistantApi.Domain.Entities;
+using ShoppingAssistantApi.Domain.Enums;
+using ServerSentEvent = ShoppingAssistantApi.Application.Models.ProductSearch.ServerSentEvent;
+
+namespace ShoppingAssistantApi.Infrastructure.Services;
+
+public class ProductService : IProductService
+{
+    private readonly IWishlistsService _wishlistsService;
+    
+    private readonly IOpenAiService _openAiService;
+
+    private readonly IMessagesRepository _messagesRepository;
+    
+    private bool mqchecker = false;
+    
+    private SearchEventType currentDataType = SearchEventType.Wishlist;
+
+    public ProductService(IOpenAiService openAiService, IWishlistsService wishlistsService, IMessagesRepository messagesRepository)
+    {
+        _openAiService = openAiService;
+        _wishlistsService = wishlistsService;
+        _messagesRepository = messagesRepository;
+    }
+    
+    public async IAsyncEnumerable<ServerSentEvent> SearchProductAsync(string wishlistId, MessageCreateDto message, CancellationToken cancellationToken)
+    {
+        string promptForGpt =
+            "You are a Shopping Assistant that helps people find product recommendations. Ask user additional questions if more context needed." +
+            "\nYou must return data with one of the prefixes:" +
+            "\n[Question] - return question" +
+            "\n[Suggestions] - return semicolon separated suggestion how to answer to a question" +
+            "\n[Message] - return text" +
+            "\n[Products] - return semicolon separated product names";
+        
+        var countOfMessage = await _messagesRepository
+            .GetCountAsync(message=>message.WishlistId == ObjectId.Parse((wishlistId)), cancellationToken);
+
+        var previousMessages = await _wishlistsService
+            .GetMessagesPageFromPersonalWishlistAsync(wishlistId, 1, countOfMessage, cancellationToken);
+
+        var chatRequest = new ChatCompletionRequest
+        {
+            Messages = new List<OpenAiMessage>
+            {
+                new OpenAiMessage
+                {
+                    Role = OpenAiRoleExtensions.RequestConvert(OpenAiRole.System),
+                    Content = promptForGpt
+                }
+            }
+        };
+        
+        
+        var messagesForOpenAI = new List<OpenAiMessage>();
+        
+        foreach (var item in previousMessages.Items)
+        {
+            if (item.Role == "Application")
+            {
+                messagesForOpenAI
+                    .Add(new OpenAiMessage()
+                    {
+                        Role = OpenAiRole.Assistant.RequestConvert(),
+                        Content = item.Text
+                    });
+            }
+            else
+            {
+                messagesForOpenAI
+                    .Add(new OpenAiMessage()
+                    {
+                        Role = item.Role.ToLower(),
+                        Content = item.Text
+                    });
+            }
+        }
+            
+        messagesForOpenAI.Add(new OpenAiMessage()
+        {
+            Role = OpenAiRoleExtensions.RequestConvert(OpenAiRole.User),
+            Content = message.Text
+        });
+            
+        chatRequest.Messages.AddRange(messagesForOpenAI);
+            
+        var suggestionBuffer = new Suggestion();
+        var messageBuffer = new MessagePart();
+        var productBuffer = new ProductName();
+        var dataTypeHolder = string.Empty;
+        var counter = 0;
+
+        await foreach (var data in _openAiService.GetChatCompletionStream(chatRequest, cancellationToken))
+        {
+            counter++;
+            if (mqchecker && currentDataType == SearchEventType.Message && messageBuffer != null)
+            {
+                if (data == "[")
+                {
+                    _wishlistsService.AddMessageToPersonalWishlistAsync(wishlistId, new MessageDto()
+                    {
+                        Text = messageBuffer.Text,
+                        Role = MessageRoles.Application.ToString(),
+                    }, cancellationToken);
+                    mqchecker = false;
+                }
+            }
+            
+            if (data.Contains("["))
+            {
+                dataTypeHolder = string.Empty;
+                dataTypeHolder += data;
+            }
+
+            else if (data.Contains("]"))
+            {
+                dataTypeHolder += data;
+                currentDataType = DetermineDataType(dataTypeHolder);
+                if (currentDataType == SearchEventType.Message)
+                {
+                    mqchecker = true;
+                }
+            }
+
+            else if (dataTypeHolder=="[" && !data.Contains("["))
+            {
+                dataTypeHolder += data;
+            }
+            
+            else
+            {
+                switch (currentDataType)
+                {
+                    case SearchEventType.Message:
+                        yield return new ServerSentEvent
+                        {
+                            Event = SearchEventType.Message,
+                            Data = data
+                        };
+                        currentDataType = SearchEventType.Message;
+                        messageBuffer.Text += data;
+                        break;
+
+                    case SearchEventType.Suggestion:
+                        if (data.Contains(";"))
+                        {
+                            yield return new ServerSentEvent
+                            {
+                                Event = SearchEventType.Suggestion,
+                                Data = suggestionBuffer.Text
+                            };
+                            suggestionBuffer.Text = string.Empty;
+                            break;
+                        } 
+                        suggestionBuffer.Text += data;
+                        break;
+                        
+                    case SearchEventType.Product:
+                        if (data.Contains(";"))
+                        {
+                            yield return new ServerSentEvent
+                            {
+                                Event = SearchEventType.Product,
+                                Data = productBuffer.Name
+                            };
+                            productBuffer.Name = string.Empty;
+                            break;
+                        }
+                        productBuffer.Name += data;
+                        break;  
+                }
+            }
+        }
+        if (currentDataType == SearchEventType.Message)
+        {
+            _wishlistsService.AddMessageToPersonalWishlistAsync(wishlistId, new MessageDto()
+            {
+                Text = messageBuffer.Text,
+                Role = MessageRoles.Application.ToString(),
+            }, cancellationToken);
+            mqchecker = false;
+        }
+    }
+
+    private SearchEventType DetermineDataType(string dataTypeHolder)
+    {
+        if (dataTypeHolder.StartsWith("[Question]"))
+        {
+            return SearchEventType.Message;
+        }
+        else if (dataTypeHolder.StartsWith("[Options]"))
+        {
+            return SearchEventType.Suggestion;
+        }
+        else if (dataTypeHolder.StartsWith("[Message]"))
+        {
+            return SearchEventType.Message;
+        }
+        else if (dataTypeHolder.StartsWith("[Products]"))
+        {
+            return SearchEventType.Product;
+        }
+        else
+        {
+            return SearchEventType.Wishlist;
+        }
+    }
+    
+}

ShoppingAssistantApi.Infrastructure/Services/RolesService.cs

@@ -0,0 +1,48 @@
+using AutoMapper;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.Exceptions;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Infrastructure.Services;
+
+public class RolesService : IRolesService
+{
+    private readonly IRolesRepository _repository;
+
+    private readonly IMapper _mapper;
+
+    public RolesService(IRolesRepository repository, IMapper mapper)
+    {
+        this._repository = repository;
+        this._mapper = mapper;
+    }
+
+    public async Task<RoleDto> AddRoleAsync(RoleCreateDto dto, CancellationToken cancellationToken)
+    {
+        var role = await this._repository.GetRoleAsync(r => r.Name == dto.Name, cancellationToken);
+        if (role != null)
+        {
+            throw new EntityAlreadyExistsException<Role>();
+        }
+        var entity = this._mapper.Map<Role>(dto);
+        entity.CreatedDateUtc = DateTime.UtcNow;
+        entity.LastModifiedDateUtc = DateTime.UtcNow;
+        await this._repository.AddAsync(entity, cancellationToken);
+
+        return this._mapper.Map<RoleDto>(entity);
+    }
+
+    public async Task<PagedList<RoleDto>> GetRolesPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        var entities = await this._repository.GetPageAsync(pageNumber, pageSize, cancellationToken);
+        var count = await this._repository.GetTotalCountAsync();
+        var dtos = this._mapper.Map<List<RoleDto>>(entities);
+
+        return new PagedList<RoleDto>(dtos, pageNumber, pageSize, count);
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/ServiceBase.cs

@@ -0,0 +1,15 @@
+namespace ShoppingAssistantApi.Infrastructure.Services;
+using MongoDB.Bson;
+
+public abstract class ServiceBase
+{
+    public ObjectId ParseObjectId(string? id)
+    {
+        if (ObjectId.TryParse(id, out ObjectId objectId))
+        {
+            return objectId;
+        }
+        
+        throw new InvalidDataException("Provided id cannot be parsed to a MongoDb ObjectId.");
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/UsersService.cs

@@ -0,0 +1,62 @@
+using AutoMapper;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.Exceptions;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Paging;
+using ShoppingAssistantApi.Domain.Entities;
+
+namespace ShoppingAssistantApi.Infrastructure.Services;
+
+public class UsersService : IUsersService
+{
+    private readonly IUsersRepository _repository;
+
+    private readonly IMapper _mapper;
+
+    public UsersService(IUsersRepository repository, IMapper mapper)
+    {
+        _repository = repository;
+        _mapper = mapper;
+    }
+
+    public async Task AddUserAsync(UserDto dto, CancellationToken cancellationToken)
+    {
+        var entity = _mapper.Map<User>(dto);
+        await _repository.AddAsync(entity, cancellationToken);
+    }
+
+    public async Task<PagedList<UserDto>> GetUsersPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        var entities = await _repository.GetPageAsync(pageNumber, pageSize, cancellationToken);
+        var dtos = _mapper.Map<List<UserDto>>(entities);
+        var count = await _repository.GetTotalCountAsync();
+        return new PagedList<UserDto>(dtos, pageNumber, pageSize, count);
+    }
+
+    public async Task<UserDto> GetUserAsync(string id, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(id, out var objectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var entity = await _repository.GetUserAsync(objectId, cancellationToken);
+        if (entity == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        return _mapper.Map<UserDto>(entity);
+    }
+
+    public async Task UpdateUserAsync(UserDto dto, CancellationToken cancellationToken)
+    {
+        var entity = _mapper.Map<User>(dto);
+        entity.LastModifiedById = GlobalUser.Id.Value;
+        entity.LastModifiedDateUtc = DateTime.UtcNow;
+        await _repository.UpdateUserAsync(entity, cancellationToken);
+    }
+}

ShoppingAssistantApi.Infrastructure/Services/WishlistsService.cs

@@ -0,0 +1,229 @@
+using AutoMapper;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.Exceptions;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.OpenAi;
+using ShoppingAssistantApi.Application.Paging;
+using ShoppingAssistantApi.Domain.Entities;
+using ShoppingAssistantApi.Domain.Enums;
+
+namespace ShoppingAssistantApi.Infrastructure.Services;
+
+public class WishlistsService : IWishlistsService
+{
+    private readonly IWishlistsRepository _wishlistsRepository;
+
+    private readonly IMessagesRepository _messagesRepository;
+
+    private readonly IProductsRepository _productsRepository;
+
+    private readonly IMapper _mapper;
+
+    private readonly IOpenAiService _openAiService;
+
+    public WishlistsService(IWishlistsRepository wishlistRepository, IMessagesRepository messageRepository,
+            IProductsRepository productRepository, IMapper mapper, IOpenAiService openAiService)
+    {
+        _wishlistsRepository = wishlistRepository;
+        _messagesRepository = messageRepository;
+        _productsRepository = productRepository;
+        _mapper = mapper;
+        _openAiService = openAiService;
+    }
+
+    public async Task<WishlistDto> StartPersonalWishlistAsync(WishlistCreateDto dto, CancellationToken cancellationToken)
+    {
+        var newWishlist = _mapper.Map<Wishlist>(dto);
+
+        if (!Enum.TryParse<WishlistTypes>(newWishlist.Type, true, out var enumValue) ||
+            !Enum.GetValues<WishlistTypes>().Contains(enumValue))
+        {
+            throw new InvalidDataException("Provided type is invalid.");
+        }
+
+        newWishlist.CreatedById = GlobalUser.Id.Value;
+        newWishlist.CreatedDateUtc = DateTime.UtcNow;
+        newWishlist.Name = $"{newWishlist.Type} Search";
+
+        var createdWishlist = await _wishlistsRepository.AddAsync(newWishlist, cancellationToken);
+
+        var newMessage = new Message
+        {
+            Text = dto.FirstMessageText,
+            Role = MessageRoles.Application.ToString(),
+            CreatedById = GlobalUser.Id.Value,
+            CreatedDateUtc = DateTime.UtcNow,
+            WishlistId = createdWishlist.Id
+        };
+        var createdMessage = await _messagesRepository.AddAsync(newMessage, cancellationToken);
+
+        return _mapper.Map<WishlistDto>(createdWishlist);
+    }
+
+    public async Task<WishlistDto> GenerateNameForPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var wishlist = await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+
+        var firstUserMessage = 
+            (await _messagesRepository.GetPageAsync(1, 1, x => x.WishlistId == wishlistObjectId && x.Role == MessageRoles.User.ToString(), cancellationToken)).First();
+
+        var chatCompletionRequest = new ChatCompletionRequest
+        {
+            Messages = new List<OpenAiMessage>(2)
+            {
+                new OpenAiMessage
+                {
+                    Role = OpenAiRole.System.RequestConvert(),
+                    Content = "You will be provided with a general information about some product and your task is to generate general (not specific to any company or brand) chat name where recommendations on which specific product to buy will be given. Only name he product without adverbs and adjectives\nExamples:\n  - Prompt: Hub For Macbook. Answer: Macbook Hub\n  - Prompt: What is the best power bank for MacBook with capacity 20000 mAh and power near 20V? Answer: Macbook Powerbank"
+                },
+                new OpenAiMessage
+                {
+                    Role = OpenAiRole.User.RequestConvert(),
+                    Content = firstUserMessage.Text
+                }
+            }
+        };
+
+        var openAiMessage = await _openAiService.GetChatCompletion(chatCompletionRequest, cancellationToken);
+
+        wishlist = await _wishlistsRepository.UpdateWishlistNameAsync(wishlist.Id, 
+                openAiMessage.Content, GlobalUser.Id.Value, cancellationToken);
+
+        return _mapper.Map<WishlistDto>(wishlist);
+    }
+
+    public async Task<MessageDto> AddMessageToPersonalWishlistAsync(string wishlistId, MessageDto dto, CancellationToken cancellationToken)
+    {
+        var newMessage = _mapper.Map<Message>(dto);
+
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        newMessage.CreatedById = GlobalUser.Id.Value;
+        newMessage.CreatedDateUtc = DateTime.UtcNow;
+        newMessage.WishlistId = wishlistObjectId;
+
+        await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+
+        var createdMessage = await _messagesRepository.AddAsync(newMessage, cancellationToken);
+
+        return _mapper.Map<MessageDto>(createdMessage);
+    }
+
+    public async Task<PagedList<WishlistDto>> GetPersonalWishlistsPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        var entities = await _wishlistsRepository.GetPageAsync(pageNumber, pageSize, x => x.CreatedById == GlobalUser.Id, cancellationToken);
+        var dtos = _mapper.Map<List<WishlistDto>>(entities);
+        var count = await _wishlistsRepository.GetTotalCountAsync();
+        return new PagedList<WishlistDto>(dtos, pageNumber, pageSize, count);
+    }
+
+    public async Task<WishlistDto> GetPersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var entity = await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+        
+        return _mapper.Map<WishlistDto>(entity);
+    }
+
+    public async Task<PagedList<MessageDto>> GetMessagesPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+
+        var entities = await _messagesRepository.GetPageStartingFromEndAsync(pageNumber, pageSize, x => x.WishlistId == wishlistObjectId, cancellationToken);
+
+        var dtos = _mapper.Map<List<MessageDto>>(entities);
+        var count = await _messagesRepository.GetCountAsync(x => x.WishlistId == wishlistObjectId, cancellationToken);
+        return new PagedList<MessageDto>(dtos, pageNumber, pageSize, count);
+    }
+
+    public async Task<ProductDto> AddProductToPersonalWishlistAsync(string wishlistId, ProductCreateDto dto, CancellationToken cancellationToken)
+    {
+        var newProduct = _mapper.Map<Product>(dto);
+
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+        
+        newProduct.CreatedById = GlobalUser.Id.Value;
+        newProduct.CreatedDateUtc = DateTime.UtcNow;
+        newProduct.WishlistId = wishlistObjectId;
+
+        var createdProduct = await _productsRepository.AddAsync(newProduct, cancellationToken);
+
+        return _mapper.Map<ProductDto>(createdProduct);
+    }
+
+    public async Task<PagedList<ProductDto>> GetProductsPageFromPersonalWishlistAsync(string wishlistId, int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+
+        var entities = await _productsRepository.GetPageAsync(pageNumber, pageSize, x => x.WishlistId == wishlistObjectId, cancellationToken);
+
+        var dtos = _mapper.Map<List<ProductDto>>(entities);
+        var count = await _productsRepository.GetCountAsync(x => x.WishlistId == wishlistObjectId, cancellationToken);
+        return new PagedList<ProductDto>(dtos, pageNumber, pageSize, count);
+    }
+
+    public async Task<WishlistDto> DeletePersonalWishlistAsync(string wishlistId, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(wishlistId, out var wishlistObjectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var entity = await TryGetPersonalWishlist(wishlistObjectId, cancellationToken);
+
+        entity.LastModifiedById = GlobalUser.Id;
+        entity.LastModifiedDateUtc = DateTime.UtcNow;
+
+        await _wishlistsRepository.DeleteAsync(entity, cancellationToken);
+
+        return _mapper.Map<WishlistDto>(entity);
+    }
+
+    private async Task<Wishlist> TryGetPersonalWishlist(ObjectId wishlistId, CancellationToken cancellationToken)
+    {
+        var entity = await _wishlistsRepository.GetWishlistAsync(x => x.Id == wishlistId, cancellationToken);
+
+        if (entity.CreatedById != GlobalUser.Id)
+        {
+            throw new UnAuthorizedException<Wishlist>();
+        }
+
+        if (entity == null)
+        {
+            throw new EntityNotFoundException<Wishlist>();
+        }
+
+        return entity;
+    }
+}

ShoppingAssistantApi.Infrastructure/ShoppingAssistantApi.Infrastructure.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.9" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="7.0.1" />
+    <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="6.32.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.32.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ShoppingAssistantApi.Application\ShoppingAssistantApi.Application.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Domain\ShoppingAssistantApi.Domain.csproj" />
+  </ItemGroup>
+
+</Project>