SA-7 project created

2025-04-02 23:59:35 +00:00 · 2023-09-22 23:02:20 +03:00 · 2023-09-22 23:02:20 +03:00 · ae37f4952e
commit ae37f4952e
parent b5f6cf4ae7
71 changed files with 2755 additions and 0 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -0,0 +1,35 @@
+// 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"
+	//		}
+	// }
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"kreativ-software.csharpextensions",
+				"ms-dotnettools.csharp",
+				"patcx.vscode-nuget-gallery",
+				"mhutchie.git-graph"
+			]
+		}
+	}
+	// 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"
+}
--- a/.gitignore
+++ b/.gitignore
@ -266,6 +266,9 @@ ServiceFabricBackup/
 *.ldf
 *.ndf

+# appsettings.Development.json file (ignore it)
+appsettings.Development.json
+
 # Business Intelligence projects
 *.rdl.data
 *.bim.layout
--- a/.vscode/launch.json
+++ b/.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"
+        }
+    ]
+}
--- a/.vscode/tasks.json
+++ b/.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"
+        }
+    ]
+}
--- a/ShoppingAssistantApi.Api/ApiExtentions/GlobalUserExtention.cs
+++ b/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;
+    }
+}
--- a/ShoppingAssistantApi.Api/ApiExtentions/GraphQlExtention.cs
+++ b/ShoppingAssistantApi.Api/ApiExtentions/GraphQlExtention.cs
@ -0,0 +1,24 @@
+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>()
+            .AddMutationType()
+                .AddTypeExtension<AccessMutation>()
+                .AddTypeExtension<UsersMutation>()
+                .AddTypeExtension<RolesMutation>()
+            .AddAuthorization()
+            .InitializeOnStartup(keepWarm: true);
+
+        return services;
+    }
+}
--- a/ShoppingAssistantApi.Api/Controllers/WeatherForecastController.cs
+++ b/ShoppingAssistantApi.Api/Controllers/WeatherForecastController.cs
@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace ShoppingAssistantApi.Api.Controllers;
+[ApiController]
+[Route("[controller]")]
+public class WeatherForecastController : ControllerBase
+{
+    private static readonly string[] Summaries = new[]
+    {
+        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+    };
+
+    private readonly ILogger<WeatherForecastController> _logger;
+
+    public WeatherForecastController(ILogger<WeatherForecastController> logger)
+    {
+        _logger = logger;
+    }
+
+    [HttpGet(Name = "GetWeatherForecast")]
+    public IEnumerable<WeatherForecast> Get()
+    {
+        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+        {
+            Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
+            TemperatureC = Random.Shared.Next(-20, 55),
+            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+        })
+        .ToArray();
+    }
+}
--- a/ShoppingAssistantApi.Api/CustomMiddlewares/GlobalUserCustomMiddleware.cs
+++ b/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);
+    }
+}
--- a/ShoppingAssistantApi.Api/Mutations/AccessMutation.cs
+++ b/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> RefreshUserTokenAsync(TokensModel model, CancellationToken cancellationToken,
+    [Service] ITokensService tokensService)
+    => tokensService.RefreshUserAsync(model, cancellationToken);
+}
--- a/ShoppingAssistantApi.Api/Mutations/RolesMutation.cs
+++ b/ShoppingAssistantApi.Api/Mutations/RolesMutation.cs
@ -0,0 +1,23 @@
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Api.Mutations;
+
+[ExtendObjectType(OperationTypeNames.Mutation)]
+public class RolesMutation
+{
+    public Task<TokensModel> AddToRoleAsync(string roleName, string id, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.AddToRoleAsync(roleName, id, cancellationToken);
+
+    public Task<TokensModel> RemoveFromRoleAsync(string roleName, string id, CancellationToken cancellationToken,
+        [Service] IUserManager userManager)
+        => userManager.RemoveFromRoleAsync(roleName, id, cancellationToken);
+
+    public Task<RoleDto> AddRole(RoleCreateDto roleDto, CancellationToken cancellationToken,
+        [Service] IRolesService rolesService)
+        => rolesService.AddRoleAsync(roleDto, cancellationToken);
+}
--- a/ShoppingAssistantApi.Api/Mutations/UsersMutation.cs
+++ b/ShoppingAssistantApi.Api/Mutations/UsersMutation.cs
@ -0,0 +1,20 @@
+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<UpdateUserModel> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken,
+    [Service] IUserManager userManager)
+    => userManager.UpdateUserByAdminAsync(id, userDto, cancellationToken);
+}
--- a/ShoppingAssistantApi.Api/Program.cs
+++ b/ShoppingAssistantApi.Api/Program.cs
@ -0,0 +1,49 @@
+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.
+
+// 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.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;
+using var cancellationTokenSource = new CancellationTokenSource();
+var cancellationToken = cancellationTokenSource.Token;
+var initializer = new DbInitialaizer(serviceProvider);
+initializer.InitialaizeDb(cancellationToken);
+*/
+app.Run();
+
+public partial class Program { }
--- a/ShoppingAssistantApi.Api/Properties/launchSettings.json
+++ b/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"
+      }
+    }
+  }
+}
--- a/ShoppingAssistantApi.Api/Queries/RolesQuery.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Api/Queries/UsersQuery.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj
+++ b/ShoppingAssistantApi.Api/ShoppingAssistantApi.Api.csproj
@ -0,0 +1,24 @@
+<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="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>
--- a/ShoppingAssistantApi.Api/WeatherForecast.cs
+++ b/ShoppingAssistantApi.Api/WeatherForecast.cs
@ -0,0 +1,12 @@
+namespace ShoppingAssistantApi.Api;
+
+public class WeatherForecast
+{
+    public DateOnly Date { get; set; }
+
+    public int TemperatureC { get; set; }
+
+    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
+
+    public string? Summary { get; set; }
+}
--- a/ShoppingAssistantApi.Api/appsettings.json
+++ b/ShoppingAssistantApi.Api/appsettings.json
@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}
--- a/ShoppingAssistantApi.Application/ApplicationExtensions/MapperExtension.cs
+++ b/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;
+    }
+}
--- a/ShoppingAssistantApi.Application/Exceptions/EntityAlreadyExistsException.cs
+++ b/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.") { }
+}
--- a/ShoppingAssistantApi.Application/Exceptions/EntityNotFoundException.cs
+++ b/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) { }
+}
--- a/ShoppingAssistantApi.Application/Exceptions/InvalidEmailException.cs
+++ b/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.")) { }
+}
--- a/ShoppingAssistantApi.Application/Exceptions/InvalidPhoneNumberException.cs
+++ b/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.")) { }
+}
--- a/ShoppingAssistantApi.Application/GlobalInstances/GlobalUser.cs
+++ b/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>();
+}
--- a/ShoppingAssistantApi.Application/IRepositories/IBaseRepository.cs
+++ b/ShoppingAssistantApi.Application/IRepositories/IBaseRepository.cs
@ -0,0 +1,21 @@
+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<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);
+}
--- a/ShoppingAssistantApi.Application/IRepositories/IRolesRepository.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Application/IRepositories/IUsersRepository.cs
+++ b/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);
+}
+
--- a/ShoppingAssistantApi.Application/IServices/IRolesService.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Application/IServices/IUsersService.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Application/IServices/Identity/IPasswordHasher.cs
+++ b/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);
+}
--- a/ShoppingAssistantApi.Application/IServices/Identity/ITokensService.cs
+++ b/ShoppingAssistantApi.Application/IServices/Identity/ITokensService.cs
@ -0,0 +1,13 @@
+using ShoppingAssistantApi.Application.Models.Identity;
+using System.Security.Claims;
+
+namespace ShoppingAssistantApi.Application.IServices.Identity;
+
+public interface ITokensService
+{
+    string GenerateAccessToken(IEnumerable<Claim> claims);
+
+    string GenerateRefreshToken();
+
+    Task<TokensModel> RefreshUserAsync(TokensModel tokensModel, CancellationToken cancellationToken);
+}
--- a/ShoppingAssistantApi.Application/IServices/Identity/IUsersManager.cs
+++ b/ShoppingAssistantApi.Application/IServices/Identity/IUsersManager.cs
@ -0,0 +1,20 @@
+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<TokensModel> AddToRoleAsync(string roleName, string id, CancellationToken cancellationToken);
+
+    Task<TokensModel> RemoveFromRoleAsync(string roleName, string id, CancellationToken cancellationToken);
+
+    Task<UpdateUserModel> UpdateAsync(UserDto userDto, CancellationToken cancellationToken);
+
+    Task<UpdateUserModel> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken);
+}
--- a/ShoppingAssistantApi.Application/MappingProfiles/RoleProfile.cs
+++ b/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();
+    }
+}
--- a/ShoppingAssistantApi.Application/MappingProfiles/UserProfile.cs
+++ b/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();
+    }
+}
--- a/ShoppingAssistantApi.Application/Models/CreateDtos/RoleCreateDto.cs
+++ b/ShoppingAssistantApi.Application/Models/CreateDtos/RoleCreateDto.cs
@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.CreateDtos;
+
+public class RoleCreateDto
+{
+    public string Name { get; set; }
+}
--- a/ShoppingAssistantApi.Application/Models/Dtos/RoleDto.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Models/Dtos/UserDto.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Models/Identity/AccessGuestModel.cs
+++ b/ShoppingAssistantApi.Application/Models/Identity/AccessGuestModel.cs
@ -0,0 +1,6 @@
+namespace ShoppingAssistantApi.Application.Models.Identity;
+
+public class AccessGuestModel
+{
+    public Guid GuestId { get; set; }
+}
--- a/ShoppingAssistantApi.Application/Models/Identity/AccessUserModel.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Models/Identity/TokensModel.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Models/Operations/UpdateUserModel.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Paging/PageParameters.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Application/Paging/PagedList.cs
+++ b/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;
+    }
+}
--- a/ShoppingAssistantApi.Application/ShoppingAssistantApi.Application.csproj
+++ b/ShoppingAssistantApi.Application/ShoppingAssistantApi.Application.csproj
@ -0,0 +1,19 @@
+<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>
--- a/ShoppingAssistantApi.Domain/Common/EntityBase.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Domain/Entities/Role.cs
+++ b/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; }
+}
--- a/ShoppingAssistantApi.Domain/Entities/User.cs
+++ b/ShoppingAssistantApi.Domain/Entities/User.cs
@ -0,0 +1,20 @@
+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; }
+
+    public string RefreshToken { get; set; }
+
+    public DateTime RefreshTokenExpiryDate { get; set; }
+}
--- a/ShoppingAssistantApi.Domain/ShoppingAssistantApi.Domain.csproj
+++ b/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>
--- a/ShoppingAssistantApi.Infrastructure/InfrastructureExtentions/JwtTokenAuthenticationExtention.cs
+++ b/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;
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/InfrastructureExtentions/ServicesExtention.cs
+++ b/ShoppingAssistantApi.Infrastructure/InfrastructureExtentions/ServicesExtention.cs
@ -0,0 +1,20 @@
+using Microsoft.Extensions.DependencyInjection;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Infrastructure.Services;
+using ShoppingAssistantApi.Infrastructure.Services.Identity;
+
+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>();
+
+        return services;
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/Services/Identity/PasswordHasher.cs
+++ b/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;
+        }
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/Services/Identity/TokensService.cs
+++ b/ShoppingAssistantApi.Infrastructure/Services/Identity/TokensService.cs
@ -0,0 +1,127 @@
+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 MongoDB.Bson;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Infrastructure.Services.Identity;
+
+public class TokensService : ITokensService
+{
+    private readonly IConfiguration _configuration;
+
+    private readonly IUsersRepository _usersRepository;
+
+    private readonly ILogger _logger;
+
+    public TokensService(IConfiguration configuration, IUsersRepository usersRepository,
+                            ILogger<TokensService> logger)
+    {
+        this._configuration = configuration;
+        this._usersRepository = usersRepository;
+        this._logger = logger;
+    }
+
+    public async Task<TokensModel> RefreshUserAsync(TokensModel tokensModel, CancellationToken cancellationToken)
+    {
+        var principal = this.GetPrincipalFromExpiredToken(tokensModel.AccessToken);
+
+        var userId = principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value;
+        if (!ObjectId.TryParse(userId, out var objectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var user = await this._usersRepository.GetUserAsync(objectId, cancellationToken);
+        if (user == null || user?.RefreshToken != tokensModel.RefreshToken
+            || user?.RefreshTokenExpiryDate <= DateTime.UtcNow)
+        {
+            throw new SecurityTokenExpiredException();
+        }
+
+        var newAccessToken = this.GenerateAccessToken(principal.Claims);
+        var newRefreshToken = this.GenerateRefreshToken();
+        user.RefreshToken = newRefreshToken;
+        user.RefreshTokenExpiryDate = DateTime.UtcNow.AddDays(30);
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+
+        this._logger.LogInformation($"Refreshed user tokens.");
+
+        return new TokensModel
+        {
+            AccessToken = newAccessToken,
+            RefreshToken = newRefreshToken
+        };
+    }
+
+    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;
+        }
+    }
+
+    private 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();
+        SecurityToken securityToken;
+        var principal = tokenHandler.ValidateToken(token, tokenValidationParameters, out 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(5),
+            claims: claims,
+            signingCredentials: signinCredentials
+        );
+
+        return tokenOptions;
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/Services/Identity/UserManager.cs
+++ b/ShoppingAssistantApi.Infrastructure/Services/Identity/UserManager.cs
@ -0,0 +1,302 @@
+using AutoMapper;
+using Microsoft.Extensions.Logging;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.Win32;
+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 : IUserManager
+{
+    private readonly IUsersRepository _usersRepository;
+
+    private readonly ILogger _logger;
+
+    private readonly IPasswordHasher _passwordHasher;
+
+    private readonly ITokensService _tokensService;
+
+    private readonly IMapper _mapper;
+
+    private readonly IRolesRepository _rolesRepository;
+
+    public UserManager(IUsersRepository usersRepository, ILogger<UserManager> logger, IPasswordHasher passwordHasher, ITokensService tokensService, IMapper mapper, IRolesRepository rolesRepository)
+    {
+        this._usersRepository = usersRepository;
+        this._logger = logger;
+        this._passwordHasher = passwordHasher;
+        this._tokensService = tokensService;
+        this._mapper = mapper;
+        this._rolesRepository = rolesRepository;
+
+    }
+
+    public async Task<TokensModel> LoginAsync(AccessUserModel login, CancellationToken cancellationToken)
+    {
+        var user = login.Email != null
+            ? await this._usersRepository.GetUserAsync(x => x.Email == login.Email, cancellationToken)
+            : await this._usersRepository.GetUserAsync(x => x.Phone == login.Phone, cancellationToken);
+
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        if (!this._passwordHasher.Check(login.Password, user.PasswordHash))
+        {
+            throw new InvalidDataException("Invalid password!");
+        }
+
+        user.RefreshToken = this.GetRefreshToken();
+        user.RefreshTokenExpiryDate = DateTime.UtcNow.AddDays(30);
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+        var tokens = this.GetUserTokens(user);
+
+        this._logger.LogInformation($"Logged in user with email: {login.Email}.");
+
+        return tokens;
+    }
+
+    public async Task<TokensModel> AccessGuestAsync(AccessGuestModel guest, CancellationToken cancellationToken)
+    {
+        var user = await this._usersRepository.GetUserAsync(x => x.GuestId == guest.GuestId, cancellationToken);
+
+        if (user != null)
+        {
+            user.RefreshToken = this.GetRefreshToken();
+            await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+            var userTokens = this.GetUserTokens(user);
+
+            this._logger.LogInformation($"Logged in guest with guest id: {guest.GuestId}.");
+
+            return userTokens;
+        }
+
+        var role = await this._rolesRepository.GetRoleAsync(r => r.Name == "Guest", cancellationToken);
+
+        var newUser = new User
+        {
+            GuestId = guest.GuestId,
+            Roles = new List<Role> { role },
+            RefreshToken = this.GetRefreshToken(),
+            RefreshTokenExpiryDate = DateTime.Now.AddDays(30),
+            CreatedDateUtc = DateTime.UtcNow,
+            LastModifiedDateUtc = DateTime.UtcNow
+        };
+
+        await this._usersRepository.AddAsync(newUser, cancellationToken);
+        var tokens = this.GetUserTokens(newUser);
+
+        this._logger.LogInformation($"Created guest with guest id: {guest.GuestId}.");
+
+        return tokens;
+    }
+
+    public async Task<TokensModel> AddToRoleAsync(string roleName, string id, CancellationToken cancellationToken)
+    {
+        var role = await this._rolesRepository.GetRoleAsync(r => r.Name == roleName, cancellationToken);
+        if (role == null)
+        {
+            throw new EntityNotFoundException<Role>();
+        }
+
+        if (!ObjectId.TryParse(id, out var objectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var user = await this._usersRepository.GetUserAsync(objectId, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        user.Roles.Add(role);
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+        var tokens = this.GetUserTokens(user);
+
+        this._logger.LogInformation($"Added role {roleName} to user with id: {id}.");
+
+        return tokens;
+    }
+
+    public async Task<TokensModel> RemoveFromRoleAsync(string roleName, string id, CancellationToken cancellationToken)
+    {
+        var role = await this._rolesRepository.GetRoleAsync(r => r.Name == roleName, cancellationToken);
+        if (role == null)
+        {
+            throw new EntityNotFoundException<Role>();
+        }
+
+        if (!ObjectId.TryParse(id, out var objectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var user = await this._usersRepository.GetUserAsync(objectId, cancellationToken);
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        var deletedRole = user.Roles.Find(x => x.Name == role.Name);
+
+        user.Roles.Remove(deletedRole);
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+        var tokens = this.GetUserTokens(user);
+
+        this._logger.LogInformation($"Added role {roleName} to user with id: {id}.");
+
+        return tokens;
+    }
+
+    public async Task<UpdateUserModel> UpdateAsync(UserDto userDto, CancellationToken cancellationToken)
+    {
+        if (userDto.Email != null) ValidateEmail(userDto.Email);
+        if (userDto.Phone != null) ValidateNumber(userDto.Phone);
+
+        if (userDto.Roles.Any(x => x.Name == "Guest") && !userDto.Roles.Any(x => x.Name == "User"))
+        {
+            if (userDto.Password != null && (userDto.Email != null || userDto.Phone != null))
+            {
+                var roleEntity = await this._rolesRepository.GetRoleAsync(x => x.Name == "User", cancellationToken);
+                var roleDto = this._mapper.Map<RoleDto>(roleEntity);
+                userDto.Roles.Add(roleDto);
+            }
+        }
+
+        var user = await this._usersRepository.GetUserAsync(x => x.Id == GlobalUser.Id, cancellationToken);
+
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        if (userDto.Roles.Any(x => x.Name == "User") && userDto.Email != null)
+        {
+            if (await this._usersRepository.GetUserAsync(x => x.Email == userDto.Email, cancellationToken) != null)
+            {
+                throw new EntityAlreadyExistsException<User>("email", userDto.Email);
+            }
+        }
+        if (userDto.Roles.Any(x => x.Name == "User") && userDto.Phone != null)
+        {
+            if (await this._usersRepository.GetUserAsync(x => x.Phone == userDto.Phone, cancellationToken) != null)
+            {
+                throw new EntityAlreadyExistsException<User>("phone", userDto.Phone);
+            }
+        }
+
+        this._mapper.Map(userDto, user);
+        if (!userDto.Password.IsNullOrEmpty())
+        {
+            user.PasswordHash = this._passwordHasher.Hash(userDto.Password);
+        }
+        user.RefreshToken = this.GetRefreshToken();
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+
+        var tokens = this.GetUserTokens(user);
+
+        this._logger.LogInformation($"Update user with id: {GlobalUser.Id.ToString()}.");
+
+        return new UpdateUserModel() { Tokens = tokens, User = this._mapper.Map<UserDto>(user) };
+    }
+
+    public async Task<UpdateUserModel> UpdateUserByAdminAsync(string id, UserDto userDto, CancellationToken cancellationToken)
+    {
+        if (!ObjectId.TryParse(id, out var objectId))
+        {
+            throw new InvalidDataException("Provided id is invalid.");
+        }
+
+        var user = await this._usersRepository.GetUserAsync(objectId, cancellationToken);
+
+        if (user == null)
+        {
+            throw new EntityNotFoundException<User>();
+        }
+
+        this._mapper.Map(userDto, user);
+
+        user.RefreshToken = this.GetRefreshToken();
+        await this._usersRepository.UpdateUserAsync(user, cancellationToken);
+
+        var tokens = this.GetUserTokens(user);
+
+        this._logger.LogInformation($"Update user with id: {id}.");
+
+        return new UpdateUserModel() { Tokens = tokens, User = this._mapper.Map<UserDto>(user) };
+    }
+
+    private string GetRefreshToken()
+    {
+        var refreshToken = this._tokensService.GenerateRefreshToken();
+
+        this._logger.LogInformation($"Returned new refresh token.");
+
+        return refreshToken;
+    }
+
+    private TokensModel GetUserTokens(User user)
+    {
+        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 = user.RefreshToken,
+        };
+    }
+
+    private IEnumerable<Claim> GetClaims(User user)
+    {
+        var claims = new List<Claim>()
+            {
+                new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
+                new Claim(ClaimTypes.Email, user.Email ?? string.Empty),
+                new Claim(ClaimTypes.MobilePhone, user.Phone ?? string.Empty),
+            };
+
+        foreach (var role in user.Roles)
+        {
+            claims.Add(new Claim(ClaimTypes.Role, role.Name));
+        }
+
+        this._logger.LogInformation($"Returned claims for user with id: {user.Id.ToString()}.");
+
+        return claims;
+    }
+
+    private void ValidateEmail(string email)
+    {
+        string regex = @"^[^@\s]+@[^@\s]+\.[^@\s]+$";
+
+        if (!Regex.IsMatch(email, regex))
+        {
+            throw new InvalidEmailException(email);
+        }
+    }
+
+    private void ValidateNumber(string phone)
+    {
+        string regex = @"^\+[0-9]{1,15}$";
+
+        if (!Regex.IsMatch(phone, regex))
+        {
+            throw new InvalidPhoneNumberException(phone);
+        }
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/Services/RolesService.cs
+++ b/ShoppingAssistantApi.Infrastructure/Services/RolesService.cs
@ -0,0 +1,46 @@
+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 dtos = this._mapper.Map<List<RoleDto>>(entities);
+        var count = await this._repository.GetTotalCountAsync();
+        return new PagedList<RoleDto>(dtos, pageNumber, pageSize, count);
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/Services/UsersService.cs
+++ b/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);
+    }
+}
--- a/ShoppingAssistantApi.Infrastructure/ShoppingAssistantApi.Infrastructure.csproj
+++ b/ShoppingAssistantApi.Infrastructure/ShoppingAssistantApi.Infrastructure.csproj
@ -0,0 +1,22 @@
+<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="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>
--- a/ShoppingAssistantApi.Persistance/Database/MongoDbContext.cs
+++ b/ShoppingAssistantApi.Persistance/Database/MongoDbContext.cs
@ -0,0 +1,19 @@
+using Microsoft.Extensions.Configuration;
+using MongoDB.Driver;
+
+namespace ShoppingAssistantApi.Persistance.Database;
+
+public class MongoDbContext
+{
+    private readonly MongoClient _client;
+
+    private readonly IMongoDatabase _db;
+
+    public MongoDbContext(IConfiguration configuration)
+    {
+        this._client = new MongoClient(configuration.GetConnectionString("MongoDb"));
+        this._db = this._client.GetDatabase(configuration.GetConnectionString("MongoDatabaseName"));
+    }
+
+    public IMongoDatabase Db => this._db;
+}
--- a/ShoppingAssistantApi.Persistance/PersistanceExtentions/DbInitialaizer.cs
+++ b/ShoppingAssistantApi.Persistance/PersistanceExtentions/DbInitialaizer.cs
@ -0,0 +1,161 @@
+using Microsoft.Extensions.DependencyInjection;
+using MongoDB.Bson;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IServices;
+using ShoppingAssistantApi.Application.IServices.Identity;
+using ShoppingAssistantApi.Application.Models.CreateDtos;
+using ShoppingAssistantApi.Application.Models.Dtos;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Persistance.PersistanceExtentions;
+
+public class DbInitialaizer
+{
+    private readonly IUsersService _usersService;
+
+    private readonly IUserManager _userManager;
+
+    private readonly IRolesService _rolesService;
+
+    private readonly ITokensService _tokensService;
+
+
+    public IEnumerable<RoleDto> Roles { get; set; }
+
+    public DbInitialaizer(IServiceProvider serviceProvider)
+    {
+        this._usersService = serviceProvider.GetService<IUsersService>();
+        this._rolesService = serviceProvider.GetService<IRolesService>();
+        this._userManager = serviceProvider.GetService<IUserManager>();
+        this._tokensService = serviceProvider.GetService<ITokensService>();
+    }
+
+    public async 
+    Task
+InitialaizeDb(CancellationToken cancellationToken)
+    {
+        await this.AddRoles(cancellationToken);
+        await this.AddUsers(cancellationToken);
+    }
+
+    public async Task AddUsers(CancellationToken cancellationToken)
+    {
+        var guestModel1 = new AccessGuestModel
+        {
+            GuestId = Guid.NewGuid(),
+        };
+
+        var guestModel2 = new AccessGuestModel
+        {
+            GuestId = Guid.NewGuid(),
+        };
+
+        var guestModel3 = new AccessGuestModel
+        {
+            GuestId = Guid.NewGuid(),
+        };
+
+        var guestModel4 = new AccessGuestModel
+        {
+            GuestId = Guid.NewGuid(),
+        };
+
+        var guestModel5 = new AccessGuestModel
+        {
+            GuestId = Guid.NewGuid(),
+        };
+
+        Task.WaitAll(
+            _userManager.AccessGuestAsync(guestModel1, cancellationToken),
+            _userManager.AccessGuestAsync(guestModel2, cancellationToken),
+            _userManager.AccessGuestAsync(guestModel3, cancellationToken),
+            _userManager.AccessGuestAsync(guestModel4, cancellationToken),
+            _userManager.AccessGuestAsync(guestModel5, cancellationToken)
+        );
+
+        var guests = await this._usersService.GetUsersPageAsync(1, 4, cancellationToken);
+        var guestsResult = guests.Items.ToList();
+
+        var user1 = new UserDto
+        {
+            Id = guestsResult[0].Id,
+            GuestId = guestsResult[0].GuestId,
+            Roles = guestsResult[0].Roles,
+            Phone = "+380953326869",
+            Email = "mykhailo.bilodid@nure.ua",
+            Password = "Yuiop12345",
+            RefreshToken = _tokensService.GenerateRefreshToken(),
+            RefreshTokenExpiryDate = DateTime.Now.AddDays(7),
+        };
+
+        var user2 = new UserDto
+        {
+            Id = guestsResult[1].Id,
+            GuestId = guestsResult[1].GuestId,
+            Roles = guestsResult[1].Roles,
+            Phone = "+380953326888",
+            Email = "serhii.shchoholiev@nure.ua",
+            Password = "Yuiop12345",
+            RefreshToken = _tokensService.GenerateRefreshToken(),
+            RefreshTokenExpiryDate = DateTime.Now.AddDays(7),
+        };
+
+        var user3 = new UserDto
+        {
+            Id = guestsResult[2].Id,
+            GuestId = guestsResult[2].GuestId,
+            Roles = guestsResult[2].Roles,
+            Phone = "+380983326869",
+            Email = "vitalii.krasnorutski@nure.ua",
+            Password = "Yuiop12345",
+            RefreshToken = _tokensService.GenerateRefreshToken(),
+            RefreshTokenExpiryDate = DateTime.Now.AddDays(7),
+        };
+
+        var user4 = new UserDto
+        {
+            Id = guestsResult[3].Id,
+            GuestId = guestsResult[3].GuestId,
+            Roles = guestsResult[3].Roles,
+            Phone = "+380953826869",
+            Email = "shopping.assistant.team@gmail.com",
+            Password = "Yuiop12345",
+            RefreshToken = _tokensService.GenerateRefreshToken(),
+            RefreshTokenExpiryDate = DateTime.Now.AddDays(7),
+        };
+        
+        GlobalUser.Id = ObjectId.Parse(user1.Id);
+        await _userManager.UpdateAsync(user1, cancellationToken);
+
+        GlobalUser.Id = ObjectId.Parse(user2.Id);
+        await _userManager.UpdateAsync(user2, cancellationToken);
+
+        GlobalUser.Id = ObjectId.Parse(user3.Id);
+        await _userManager.UpdateAsync(user3, cancellationToken);
+
+        GlobalUser.Id = ObjectId.Parse(user4.Id);
+        await _userManager.UpdateAsync(user4, cancellationToken);
+    }
+
+    public async Task AddRoles(CancellationToken cancellationToken)
+    {
+        var role1 = new RoleCreateDto
+        {
+            Name = "User"
+        };
+
+        var role2 = new RoleCreateDto
+        {
+            Name = "Admin"
+        };
+
+        var role3 = new RoleCreateDto
+        {
+            Name = "Guest"
+        };
+
+        var dto1 = await _rolesService.AddRoleAsync(role1, cancellationToken);
+        var dto2 = await _rolesService.AddRoleAsync(role2, cancellationToken);
+        var dto3 = await _rolesService.AddRoleAsync(role3, cancellationToken);
+    }
+}
--- a/ShoppingAssistantApi.Persistance/PersistanceExtentions/RepositoriesExtention.cs
+++ b/ShoppingAssistantApi.Persistance/PersistanceExtentions/RepositoriesExtention.cs
@ -0,0 +1,19 @@
+using Microsoft.Extensions.DependencyInjection;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Persistance.Database;
+using ShoppingAssistantApi.Persistance.Repositories;
+
+namespace ShoppingAssistantApi.Persistance.PersistanceExtentions;
+
+public static class RepositoriesExtention
+{
+    public static IServiceCollection AddInfrastructure(this IServiceCollection services)
+    {
+        services.AddSingleton<MongoDbContext>();
+
+        services.AddScoped<IRolesRepository, RolesRepository>();
+        services.AddScoped<IUsersRepository, UsersRepository>();
+        
+        return services;
+    }
+}
--- a/ShoppingAssistantApi.Persistance/Repositories/BaseRepository.cs
+++ b/ShoppingAssistantApi.Persistance/Repositories/BaseRepository.cs
@ -0,0 +1,72 @@
+using MongoDB.Driver;
+using ShoppingAssistantApi.Domain.Common;
+using ShoppingAssistantApi.Persistance.Database;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Persistance.Repositories;
+
+public abstract class BaseRepository<TEntity> where TEntity : EntityBase
+{
+    protected MongoDbContext _db;
+
+    protected IMongoCollection<TEntity> _collection;
+
+    public BaseRepository(MongoDbContext db, string collectionName)
+    {
+        this._db = db;
+        this._collection = _db.Db.GetCollection<TEntity>(collectionName);
+    }
+
+    public async Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken)
+    {
+        await this._collection.InsertOneAsync(entity, new InsertOneOptions(), cancellationToken);
+        return entity;
+    }
+
+    public async Task<List<TEntity>> GetPageAsync(int pageNumber, int pageSize, CancellationToken cancellationToken)
+    {
+        return await this._collection.Find(Builders<TEntity>.Filter.Empty)
+                                     .Skip((pageNumber - 1) * pageSize)
+                                     .Limit(pageSize)
+                                     .ToListAsync(cancellationToken);
+    }
+
+    public async Task<List<TEntity>> GetPageAsync(int pageNumber, int pageSize, Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken)
+    {
+        return await this._collection.Find(predicate)
+                                     .Skip((pageNumber - 1) * pageSize)
+                                     .Limit(pageSize)
+                                     .ToListAsync(cancellationToken);
+    }
+
+    public async Task<int> GetTotalCountAsync()
+    {
+        return (int)(await this._collection.EstimatedDocumentCountAsync());
+    }
+
+    public async Task<int> GetCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken)
+    {
+        return (int)(await this._collection.CountDocumentsAsync(predicate, cancellationToken: cancellationToken));
+    }
+
+    public async Task<bool> ExistsAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken)
+    {
+        return await this._collection.Find(predicate).AnyAsync(cancellationToken);
+    }
+
+    public async Task<TEntity> DeleteAsync(TEntity entity, CancellationToken cancellationToken)
+    {
+        var updateDefinition = Builders<TEntity>.Update
+        .Set(e => e.IsDeleted, true)
+        .Set(e => e.LastModifiedById, entity.LastModifiedById)
+        .Set(e => e.LastModifiedDateUtc, entity.LastModifiedDateUtc);
+
+        var options = new FindOneAndUpdateOptions<TEntity>
+        {
+            ReturnDocument = ReturnDocument.After
+        };
+
+        return await this._collection.FindOneAndUpdateAsync(
+            Builders<TEntity>.Filter.Eq(e => e.Id, entity.Id), updateDefinition, options, cancellationToken);
+    }
+}
--- a/ShoppingAssistantApi.Persistance/Repositories/RolesRepository.cs
+++ b/ShoppingAssistantApi.Persistance/Repositories/RolesRepository.cs
@ -0,0 +1,23 @@
+using MongoDB.Bson;
+using MongoDB.Driver;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Domain.Entities;
+using ShoppingAssistantApi.Persistance.Database;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Persistance.Repositories;
+
+public class RolesRepository : BaseRepository<Role>, IRolesRepository
+{
+    public RolesRepository(MongoDbContext db) : base(db, "Roles") { }
+
+    public async Task<Role> GetRoleAsync(ObjectId id, CancellationToken cancellationToken)
+    {
+        return await (await this._collection.FindAsync(x => x.Id == id)).FirstOrDefaultAsync(cancellationToken);
+    }
+
+    public async Task<Role> GetRoleAsync(Expression<Func<Role, bool>> predicate, CancellationToken cancellationToken)
+    {
+        return await (await this._collection.FindAsync(predicate)).FirstOrDefaultAsync(cancellationToken);
+    }
+}
--- a/ShoppingAssistantApi.Persistance/Repositories/UsersRepository.cs
+++ b/ShoppingAssistantApi.Persistance/Repositories/UsersRepository.cs
@ -0,0 +1,48 @@
+using MongoDB.Bson;
+using MongoDB.Driver;
+using ShoppingAssistantApi.Application.GlobalInstances;
+using ShoppingAssistantApi.Application.IRepositories;
+using ShoppingAssistantApi.Domain.Entities;
+using ShoppingAssistantApi.Persistance.Database;
+using System.Linq.Expressions;
+
+namespace ShoppingAssistantApi.Persistance.Repositories;
+
+public class UsersRepository : BaseRepository<User>, IUsersRepository
+{
+    public UsersRepository(MongoDbContext db) : base(db, "Users") { }
+
+    public async Task<User> GetUserAsync(ObjectId id, CancellationToken cancellationToken)
+    {
+        return await (await this._collection.FindAsync(x => x.Id == id)).FirstOrDefaultAsync(cancellationToken);
+    }
+
+    public async Task<User> GetUserAsync(Expression<Func<User, bool>> predicate, CancellationToken cancellationToken)
+    {
+        return await (await this._collection.FindAsync(predicate)).FirstOrDefaultAsync(cancellationToken);
+    }
+
+    public async Task<User> UpdateUserAsync(User user, CancellationToken cancellationToken)
+    {
+        var updateDefinition = Builders<User>.Update
+            .Set(u => u.Email, user.Email)
+            .Set(u => u.Phone, user.Phone)
+            .Set(u => u.RefreshToken, user.RefreshToken)
+            .Set(u => u.RefreshTokenExpiryDate, user.RefreshTokenExpiryDate)
+            .Set(u => u.GuestId, user.GuestId)
+            .Set(u => u.Roles, user.Roles)
+            .Set(u => u.PasswordHash, user.PasswordHash)
+            .Set(u => u.LastModifiedDateUtc, DateTime.UtcNow)
+            .Set(u => u.LastModifiedById, GlobalUser.Id);
+
+        var options = new FindOneAndUpdateOptions<User>
+        {
+            ReturnDocument = ReturnDocument.After
+        };
+
+        return await this._collection.FindOneAndUpdateAsync(
+            Builders<User>.Filter.Eq(u => u.Id, user.Id), updateDefinition, options, cancellationToken);
+
+    }
+
+}
--- a/ShoppingAssistantApi.Persistance/ShoppingAssistantApi.Persistance.csproj
+++ b/ShoppingAssistantApi.Persistance/ShoppingAssistantApi.Persistance.csproj
@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="7.0.0" />
+    <PackageReference Include="MongoDB.Driver" Version="2.20.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ShoppingAssistantApi.Application\ShoppingAssistantApi.Application.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Domain\ShoppingAssistantApi.Domain.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/ShoppingAssistantApi.Tests/ShoppingAssistantApi.Tests.csproj
+++ b/ShoppingAssistantApi.Tests/ShoppingAssistantApi.Tests.csproj
@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL.Client" Version="6.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.9" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Mongo2Go" Version="3.1.3" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.2.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ShoppingAssistantApi.Api\ShoppingAssistantApi.Api.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Application\ShoppingAssistantApi.Application.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Infrastructure\ShoppingAssistantApi.Infrastructure.csproj" />
+    <ProjectReference Include="..\ShoppingAssistantApi.Persistance\ShoppingAssistantApi.Persistance.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/ShoppingAssistantApi.Tests/TestExtentions/AccessExtention.cs
+++ b/ShoppingAssistantApi.Tests/TestExtentions/AccessExtention.cs
@ -0,0 +1,65 @@
+using System.Text;
+using Newtonsoft.Json;
+using ShoppingAssistantApi.Application.Models.Identity;
+
+namespace ShoppingAssistantApi.Tests.TestExtentions;
+
+public static class AccessExtention
+{
+    public static async Task<TokensModel> Login(string email, string password, HttpClient httpClient)
+    {
+        var mutation = new
+        {
+            query = "mutation Login($login: AccessUserModelInput!) { login(login: $login) { accessToken refreshToken }}",
+            variables = new
+            {
+                login = new
+                {
+                    email = email,
+                    password = password
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await httpClient.PostAsync("graphql", content);
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        return new TokensModel
+        {
+            AccessToken = (string)document.data.login.accessToken,
+            RefreshToken = (string)document.data.login.refreshToken
+        };
+    }
+
+    public static async Task<TokensModel> CreateGuest(string guestId, HttpClient httpClient)
+    {
+        var mutation = new
+        {
+            query = "mutation AccessGuest($guest: AccessGuestModelInput!) { accessGuest(guest: $guest) { accessToken, refreshToken } }",
+            variables = new
+            {
+                guest = new
+                {
+                    guestId
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await httpClient.PostAsync("graphql", content);
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        return new TokensModel
+        {
+            AccessToken = (string)document.data.accessGuest.accessToken,
+            RefreshToken = (string)document.data.accessGuest.refreshToken
+        };
+    }
+}
--- a/ShoppingAssistantApi.Tests/TestExtentions/TestingFactory.cs
+++ b/ShoppingAssistantApi.Tests/TestExtentions/TestingFactory.cs
@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Mongo2Go;
+using ShoppingAssistantApi.Persistance.PersistanceExtentions;
+
+namespace ShoppingAssistantApi.Tests.TestExtentions;
+
+public class TestingFactory<TEntryPoint> : WebApplicationFactory<Program> where TEntryPoint : Program
+{
+    private readonly MongoDbRunner _runner = MongoDbRunner.Start();
+
+    private bool _isDataInitialaized = false;
+
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.ConfigureAppConfiguration((context, config) =>
+        {
+            var dbConfig = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string>()
+            {
+                { "ConnectionStrings:MongoDb", _runner.ConnectionString }
+            })
+            .Build();
+
+            config.AddConfiguration(dbConfig);
+        });
+    }
+
+    public async Task InitialaizeData()
+    {
+        if (!_isDataInitialaized)
+        {
+            _isDataInitialaized = true;
+            using var scope = Services.CreateScope();
+            var initialaizer = new DbInitialaizer(scope.ServiceProvider);
+            using var cancellationTokenSource = new CancellationTokenSource();
+            var cancellationToken = cancellationTokenSource.Token;
+            await initialaizer.InitialaizeDb(cancellationToken);
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        _runner.Dispose();
+        base.Dispose(disposing);
+    }
+}
--- a/ShoppingAssistantApi.Tests/TestExtentions/UserExtention.cs
+++ b/ShoppingAssistantApi.Tests/TestExtentions/UserExtention.cs
@ -0,0 +1,50 @@
+using System.Net.Http.Headers;
+using System.Text;
+using Newtonsoft.Json;
+using ShoppingAssistantApi.Application.Models.Dtos;
+
+namespace ShoppingAssistantApi.Tests.TestExtentions;
+
+public static class UserExtention
+{
+    public static async Task<UserDto> GetCurrentUser(HttpClient httpClient)
+    {
+        var query = new
+        {
+            query = "query CurrentUser { currentUser { id, guestId, phone, email, refreshToken, refreshTokenExpiryDate, roles { id, name }}}",
+            variables = new { }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await httpClient.PostAsync("graphql", content);
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+        return JsonConvert.DeserializeObject<UserDto>(document.data.currentUser.ToString());
+    }
+
+    public static async Task<List<UserDto>> GetUsers(int amount, HttpClient httpClient)
+    {
+        var accessToken = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", httpClient);
+        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken.AccessToken);
+
+        var query = new
+        {
+            query = "query UsersPage($pageNumber: Int!, $pageSize: Int!) { usersPage(pageNumber: $pageNumber, pageSize: $pageSize) { items { id, email, phone }}}",
+            variables = new
+            {
+                pageNumber = 1,
+                pageSize = amount
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await httpClient.PostAsync("graphql", content);
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+        return JsonConvert.DeserializeObject<List<UserDto>>(document.data.usersPage.items.ToString());
+    }
+}
--- a/ShoppingAssistantApi.Tests/Tests/AccessTests.cs
+++ b/ShoppingAssistantApi.Tests/Tests/AccessTests.cs
@ -0,0 +1,203 @@
+using System.Net;
+using System.Text;
+using Xunit;
+using ShoppingAssistantApi.Tests.TestExtentions;
+using Newtonsoft.Json;
+
+namespace ShoppingAssistantApi.Tests.Tests;
+
+[Collection("Tests")]
+
+public class AccessTests : IClassFixture<TestingFactory<Program>>
+{
+    private readonly HttpClient _httpClient;
+
+    public AccessTests(TestingFactory<Program> factory)
+    {
+        _httpClient = factory.CreateClient();
+        factory.InitialaizeData().GetAwaiter().GetResult();
+    }
+
+    [Fact]
+    public async Task AccessGuestAsync_ValidGuid_ReturnsTokensModel()
+    {
+        var mutation = new
+        {
+            query = "mutation AccessGuest($guest: AccessGuestModelInput!) { accessGuest(guest: $guest) { accessToken, refreshToken } }",
+            variables = new
+            {
+                guest = new
+                {
+                    guestId = Guid.NewGuid(),
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+        
+        var accessToken = (string)document.data.accessGuest.accessToken;
+        var refreshToken = (string)document.data.accessGuest.refreshToken;
+
+        Assert.NotNull(accessToken);
+        Assert.NotNull(refreshToken);
+        }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("invalid-guid-format")]
+    public async Task AccessGuestAsync_InvalidGuid_ReturnsInternalServerError(string guestId)
+    {
+        var mutation = new
+        {
+            query = "mutation AccessGuest($guest: AccessGuestModelInput!) { accessGuest(guest: $guest) { accessToken, refreshToken } }",
+            variables = new
+            {
+                guest = new
+                {
+                    guestId
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("invalid-email-format", null, "Yuiop12345")]
+    [InlineData(null, null, "Yuiop12345")]
+    [InlineData(null, null, "")]
+    [InlineData("mihail.beloded.work@gmail.com", null, "")]
+    public async Task LoginAsync_InvalidCredentials_ReturnsInternalServerError(string email, string phone, string password)
+    {
+        var mutation = new
+        {
+            query = "mutation Login($login: AccessUserModelInput!) { login(login: $login) { accessToken refreshToken }}",
+            variables = new
+            {
+                login = new
+                {
+                    phone = phone,
+                    email = email,
+                    password = password
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("mykhailo.bilodid@nure.ua", "+380953326869", "Yuiop12345")]
+    [InlineData(null, "+380953326888", "Yuiop12345")]
+    [InlineData("mykhailo.bilodid@nure.ua", null, "Yuiop12345")]
+    public async Task LoginAsync_ValidCredentials_ReturnsTokensModel(string email, string phone, string password)
+    {
+        var mutation = new
+        {
+            query = "mutation Login($login: AccessUserModelInput!) { login(login: $login) { accessToken refreshToken }}",
+            variables = new
+            {
+                login = new
+                {
+                    phone = phone,
+                    email = email,
+                    password = password
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessToken = (string)document.data.login.accessToken;
+        var refreshToken = (string)document.data.login.refreshToken;
+
+        Assert.NotNull(accessToken);
+        Assert.NotNull(refreshToken);
+    }
+
+    [Fact]
+    public async Task RefreshUserTokenAsync_ValidTokensModel_ReturnsTokensModel()
+    {
+        var tokensModel = await AccessExtention.CreateGuest(new Guid().ToString(), _httpClient);
+        var accessToken = tokensModel.AccessToken;
+        var refreshToken = tokensModel.RefreshToken;
+
+        var mutation = new
+        {
+            query = "mutation RefreshToken($model: TokensModelInput!) { refreshUserToken(model: $model) { accessToken refreshToken }}",
+            variables = new
+            {
+                model = new
+                {
+                    accessToken,
+                    refreshToken
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessTokenResult = (string)document.data.refreshUserToken.accessToken;
+        var refreshTokenResult = (string)document.data.refreshUserToken.refreshToken;
+
+        Assert.NotNull(accessTokenResult);
+        Assert.NotNull(refreshTokenResult);
+    }
+
+    [Theory]
+    [InlineData(null, null)]
+    [InlineData("invalid-access-token", "invalid-refresh-token")]
+    public async Task RefreshUserTokenAsync_InvalidTokensModel_ReturnsInternalServerError(string refreshToken, string accessToken)
+    {
+        var mutation = new
+        {
+            query = "mutation RefreshToken($model: TokensModelInput!) { refreshUserToken(model: $model) { accessToken refreshToken }}",
+            variables = new
+            {
+                model = new
+                {
+                    accessToken,
+                    refreshToken
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+}
--- a/ShoppingAssistantApi.Tests/Tests/RolesTests.cs
+++ b/ShoppingAssistantApi.Tests/Tests/RolesTests.cs
@ -0,0 +1,184 @@
+using System.Net;
+using System.Text;
+using Xunit;
+using ShoppingAssistantApi.Tests.TestExtentions;
+using System.Net.Http.Headers;
+using Newtonsoft.Json;
+using GreenDonut;
+
+namespace ShoppingAssistantApi.Tests.Tests;
+
+[Collection("Tests")]
+public class RolesTests : IClassFixture<TestingFactory<Program>>
+{
+    private readonly HttpClient _httpClient;
+
+    public RolesTests(TestingFactory<Program> factory)
+    {
+        _httpClient = factory.CreateClient();
+        factory.InitialaizeData().GetAwaiter().GetResult();
+    }
+
+    [Fact]
+    public async Task AddToRoleAsync_ValidRoleName_ReturnsTokensModel()
+    {
+        var usersPage = await UserExtention.GetUsers(10, _httpClient);
+        var mutation = new
+        {
+            query = "mutation AddToRole($roleName: String!, $id: String!) { addToRole(roleName: $roleName, id: $id) { accessToken, refreshToken }}",
+            variables = new
+            {
+                roleName = "Admin",
+                id = usersPage[0].Id,
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessToken = (string)document.data.addToRole.accessToken;
+        var refreshToken = (string)document.data.addToRole.refreshToken;
+
+        Assert.NotNull(accessToken);
+        Assert.NotNull(refreshToken);
+    }
+
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("InvalidRole")]
+    public async Task AddToRoleAsync_InvalidRoleName_ReturnsInternalServerError(string roleName)
+    {
+        var usersPage = await UserExtention.GetUsers(10, _httpClient);
+        var mutation = new
+        {
+            query = "mutation AddToRole($roleName: String!, $id: String!) { addToRole(roleName: $roleName, id: $id) { accessToken, refreshToken }}",
+            variables = new
+            {
+                roleName,
+                id = usersPage[0].Id,
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+
+    [Fact]
+    public async Task RemoveFromRoleAsync_ValidRoleName_ReturnsTokensModel()
+    {
+        var usersPage = await UserExtention.GetUsers(10, _httpClient);
+        var mutation = new
+        {
+            query = "mutation RemoveFromRole($roleName: String!, $id: String!) { removeFromRole(roleName: $roleName, id: $id) { accessToken, refreshToken }}",
+            variables = new
+            {
+                roleName = "Admin",
+                id = usersPage[0].Id,
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessToken = (string)document.data.removeFromRole.accessToken;
+        var refreshToken = (string)document.data.removeFromRole.refreshToken;
+
+        Assert.NotNull(accessToken);
+        Assert.NotNull(refreshToken);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("InvalidRole")]
+    public async Task RemoveFromRoleAsync_InvalidRoleName_ReturnsInternalServerError(string roleName)
+    {
+        var usersPage = await UserExtention.GetUsers(10, _httpClient);
+        var mutation = new
+        {
+            query = "mutation RemoveFromRole($roleName: String!, $id: String!) { removeFromRole(roleName: $roleName, id: $id) { accessToken, refreshToken }}",
+            variables = new
+            {
+                roleName,
+                id = usersPage[0].Id,
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("User")]
+    [InlineData(null)]
+    public async Task AddRole_InvalidRoleName_ReturnsInternalServerError(string roleName)
+    {
+        var mutation = new
+        {
+            query = "mutation AddRole ($dto: RoleCreateDtoInput!){ addRole (roleDto: $dto) { id, name }} ",
+            variables = new
+            {
+                dto = new
+                {
+                    name = roleName
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task GetRolesPageAsync_ValidPageNumberAndSize_ReturnsRolesPagedList()
+    {
+        var tokensModel = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+        var query = new
+        {
+            query = "query RolesPage($pageNumber: Int!, $pageSize: Int!) { rolesPage(pageNumber: $pageNumber, pageSize: $pageSize) { items { id, name } }}",
+            variables = new
+            {
+                pageNumber = 1,
+                pageSize = 3
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var items = document.data.rolesPage.items;
+        Assert.NotEmpty(items);
+    }
+}
--- a/ShoppingAssistantApi.Tests/Tests/UsersTests.cs
+++ b/ShoppingAssistantApi.Tests/Tests/UsersTests.cs
@ -0,0 +1,240 @@
+using ShoppingAssistantApi.Tests.TestExtentions;
+using System.Net.Http.Headers;
+using System.Net;
+using System.Text;
+using Xunit;
+using Newtonsoft.Json;
+using ShoppingAssistantApi.Application.Models.Dtos;
+
+namespace ShoppingAssistantApi.Tests.Tests;
+
+[Collection("Tests")]
+public class UsersTests : IClassFixture<TestingFactory<Program>>
+{
+    private readonly HttpClient _httpClient;
+
+    public UsersTests(TestingFactory<Program> factory)
+    {
+        _httpClient = factory.CreateClient();
+        factory.InitialaizeData().GetAwaiter().GetResult();
+    }
+
+    [Fact]
+    public async Task UpdateUserAsync_ValidUserModel_ReturnsUpdateUserModel()
+    {
+        var tokensModel = await AccessExtention.CreateGuest(Guid.NewGuid().ToString(), _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var user = await UserExtention.GetCurrentUser(_httpClient);
+
+        var roles = new object[1];
+
+        foreach(var role in user.Roles)
+        {
+            roles[0] = new
+            {
+                id = role.Id,
+                name = role.Name
+            };
+        }
+
+        var mutation = new
+        {
+            query = "mutation UpdateUser($userDto: UserDtoInput!) { updateUser(userDto: $userDto) { tokens { accessToken, refreshToken }, user { email } }}",
+            variables = new
+            {
+                userDto = new
+                {
+                    id = user.Id,
+                    guestId = user.GuestId,
+                    roles = roles,
+                    email = "testing@gmail.com",
+                    password = "Yuiop12345",
+                    refreshTokenExpiryDate = user.RefreshTokenExpiryDate
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessTokenResult = (string)document.data.updateUser.tokens.accessToken;
+        var refreshTokenResult = (string)document.data.updateUser.tokens.refreshToken;
+        var userResult = JsonConvert.DeserializeObject<UserDto>(document.data.updateUser.user.ToString());
+
+        Assert.NotNull(accessTokenResult);
+        Assert.NotNull(refreshTokenResult);
+        Assert.NotNull(userResult.Email);
+    }
+
+    [Fact]
+    public async Task UpdateUserByAdminAsync_ValidUserModel_ReturnsUpdateUserModel()
+    {
+        var tokensModel = await AccessExtention.CreateGuest(new Guid().ToString(), _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var user = await UserExtention.GetCurrentUser(_httpClient);
+
+        var roles = new object[1];
+
+        foreach (var role in user.Roles)
+        {
+            roles[0] = new
+            {
+                id = role.Id,
+                name = role.Name,
+            };
+        }
+
+        var mutation = new
+        {
+            query = "mutation UpdateUserByAdmin($id: String!, $userDto: UserDtoInput!) { updateUserByAdmin(id: $id, userDto: $userDto) { tokens { accessToken, refreshToken }, user { guestId } }}",
+            variables = new
+            {
+                id = user.Id,
+                userDto = new
+                {
+                    id = user.Id,
+                    guestId = Guid.NewGuid().ToString(),
+                    roles = roles,
+                    refreshTokenExpiryDate = user.RefreshTokenExpiryDate
+                }
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(mutation);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var accessTokenResult = (string)document.data.updateUserByAdmin.tokens.accessToken;
+        var refreshToken = (string)document.data.updateUserByAdmin.tokens.refreshToken;
+        var updatedUserGuestId = (Guid)document.data.updateUserByAdmin.user.guestId;
+
+        Assert.NotNull(accessTokenResult);
+        Assert.NotNull(refreshToken);
+        Assert.NotEqual(user.GuestId, updatedUserGuestId);
+    }
+
+    [Fact]
+    public async Task GetUserAsync_ValidUserId_ReturnsUser()
+    {
+        var tokensModel = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var usersPage = await UserExtention.GetUsers(10, _httpClient);
+        var query = new
+        {
+            query = "query User($id: String!) { user(id: $id) { id, email, phone }}",
+            variables = new
+            {
+                id = usersPage[0].Id,
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+        var userResult = JsonConvert.DeserializeObject<UserDto>(document.data.user.ToString());
+        Assert.Equal(userResult.Id, usersPage[0].Id);
+    }
+
+    [Fact]
+    public async Task GetUserAsync_InvalidUserId_ReturnsInternalServerError()
+    {
+        var tokensModel = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var query = new
+        {
+            query = "query User($id: String!) { user(id: $id) { id, email, phone }}",
+            variables = new
+            {
+                id = "error",
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task GetCurrentUserAsync_ValidCredentials_ReturnsCurrentUser()
+    {
+        var tokensModel = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var query = new
+        {
+            query = "query CurrentUser { currentUser { id, email, phone }}",
+            variables = new { }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var user = JsonConvert.DeserializeObject<UserDto>(document.data.currentUser.ToString());
+        Assert.NotEmpty(user.Id);
+        Assert.NotEmpty(user.Email);
+        Assert.NotEmpty(user.Phone);
+        Assert.Equal(user.Email, "mykhailo.bilodid@nure.ua");
+    }
+
+    [Fact]
+    public async Task GetUsersPageAsync_ValidPageNumberAndSize_ReturnsUsersPage()
+    {
+        var tokensModel = await AccessExtention.Login("mykhailo.bilodid@nure.ua", "Yuiop12345", _httpClient);
+        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", tokensModel.AccessToken);
+
+        var query = new
+        {
+            query = "query UsersPage($pageNumber: Int!, $pageSize: Int!) { usersPage(pageNumber: $pageNumber, pageSize: $pageSize) { items { id, email, phone }}}",
+            variables = new
+            {
+                pageNumber = 1,
+                pageSize = 10
+            }
+        };
+
+        var jsonPayload = JsonConvert.SerializeObject(query);
+        var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
+
+        using var response = await _httpClient.PostAsync("graphql", content);
+        response.EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var responseString = await response.Content.ReadAsStringAsync();
+        var document = JsonConvert.DeserializeObject<dynamic>(responseString);
+
+        var items = document.data.usersPage.items;
+        Assert.NotEmpty(items);
+    }
+}
--- a/ShoppingAssistantApi.sln
+++ b/ShoppingAssistantApi.sln
@ -0,0 +1,55 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.6.33723.286
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ShoppingAssistantApi.Domain", "ShoppingAssistantApi.Domain\ShoppingAssistantApi.Domain.csproj", "{22D8EA12-362A-4B61-9E03-67A44B0762F3}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ShoppingAssistantApi.Application", "ShoppingAssistantApi.Application\ShoppingAssistantApi.Application.csproj", "{9B114C53-F28F-45FE-9724-6A1FFC1C7384}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ShoppingAssistantApi.Infrastructure", "ShoppingAssistantApi.Infrastructure\ShoppingAssistantApi.Infrastructure.csproj", "{6CB12F83-2121-4A3C-ADA2-C6F3A7EDB05F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ShoppingAssistantApi.Persistance", "ShoppingAssistantApi.Persistance\ShoppingAssistantApi.Persistance.csproj", "{4F4A48F4-5989-4C26-B87C-CDF47BDFF239}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ShoppingAssistantApi.Api", "ShoppingAssistantApi.Api\ShoppingAssistantApi.Api.csproj", "{77578C0F-EBAD-4CF3-A9D5-9AFFD931E629}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ShoppingAssistantApi.Tests", "ShoppingAssistantApi.Tests\ShoppingAssistantApi.Tests.csproj", "{297B5378-79D7-406C-80A5-151C6B3EA147}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{22D8EA12-362A-4B61-9E03-67A44B0762F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{22D8EA12-362A-4B61-9E03-67A44B0762F3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{22D8EA12-362A-4B61-9E03-67A44B0762F3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{22D8EA12-362A-4B61-9E03-67A44B0762F3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9B114C53-F28F-45FE-9724-6A1FFC1C7384}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9B114C53-F28F-45FE-9724-6A1FFC1C7384}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9B114C53-F28F-45FE-9724-6A1FFC1C7384}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9B114C53-F28F-45FE-9724-6A1FFC1C7384}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6CB12F83-2121-4A3C-ADA2-C6F3A7EDB05F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6CB12F83-2121-4A3C-ADA2-C6F3A7EDB05F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6CB12F83-2121-4A3C-ADA2-C6F3A7EDB05F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6CB12F83-2121-4A3C-ADA2-C6F3A7EDB05F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4F4A48F4-5989-4C26-B87C-CDF47BDFF239}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4F4A48F4-5989-4C26-B87C-CDF47BDFF239}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4F4A48F4-5989-4C26-B87C-CDF47BDFF239}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4F4A48F4-5989-4C26-B87C-CDF47BDFF239}.Release|Any CPU.Build.0 = Release|Any CPU
+		{77578C0F-EBAD-4CF3-A9D5-9AFFD931E629}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{77578C0F-EBAD-4CF3-A9D5-9AFFD931E629}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{77578C0F-EBAD-4CF3-A9D5-9AFFD931E629}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{77578C0F-EBAD-4CF3-A9D5-9AFFD931E629}.Release|Any CPU.Build.0 = Release|Any CPU
+		{297B5378-79D7-406C-80A5-151C6B3EA147}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{297B5378-79D7-406C-80A5-151C6B3EA147}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{297B5378-79D7-406C-80A5-151C6B3EA147}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{297B5378-79D7-406C-80A5-151C6B3EA147}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {AEC96C8E-AD84-48AC-A0F6-742F94B0C3A8}
+	EndGlobalSection
+EndGlobal