Merge pull request 'Configured auto-deploy' (#23) from dev into main

Reviewed-on: http://git.lisoveliy.su/Lisoveliy/JOBot/pulls/23

.gitea/workflows/deploy-dev.yml

@@ -0,0 +1,23 @@
+name: Publish JOBot on dev
+on: [push]
+branch: dev
+
+jobs:
+  build and deploy:
+    runs-on: host
+    name: Build and deploy
+    volumes:
+      
+    steps:
+      - name: Update repo
+        run: |
+          pwd
+          cd /home/dockeruser/jobot-stack
+          git checkout dev
+          git pull
+          docker compose -f compose.dev.yml up -d postgres
+          
+          cd /home/dockeruser/jobot-stack/JOBot.Backend
+          dotnet ef database update -- --environment Development
+          docker compose up --build -d
+          

JOBot.Backend/Controllers/HeadHunterHookController.cs

@@ -0,0 +1,23 @@
+using JOBot.Backend.Services;
+using Microsoft.AspNetCore.Mvc;
+
+namespace JOBot.Backend.Controllers;
+
+[ApiController]
+[Route("auth")]
+public class HeadHunterHookController(HeadHunterService hhService)
+    : ControllerBase
+{
+
+    [HttpGet]
+    public async Task<IActionResult> Get(int userId, string? error, string code)
+    {
+        var res = await hhService.AuthUser(userId, code, error);
+        return res switch
+        {
+            HeadHunterService.Status.Success =>  Ok("Авторизация завершена успешно. Вернитесь в Telegram для продолжения."),
+            HeadHunterService.Status.UserNotFoundError => NotFound("Пользователь не найден."),
+            _ => BadRequest("Авторизация завершена с ошибкой. Вернитесь в Telegram для продолжения.") //TODO: Add resource
+        };
+    }
+}

JOBot.Backend/DTOs/HeadHunterHook/HeadHunterTokenResponseDto.cs

@@ -0,0 +1,14 @@
+using System.Text.Json.Serialization;
+
+namespace JOBot.Backend.DTOs.HeadHunterHook;
+
+public record HeadHunterTokenResponseDto(
+    [property:JsonPropertyName("access_token")]
+    string AccessToken,
+    [property:JsonPropertyName("expires_in")]
+    int ExpiresIn,
+    [property:JsonPropertyName("refresh_token")]
+    string RefreshToken,
+    [property:JsonPropertyName("token_type")]
+    string TokenType
+    );

JOBot.Backend/Dockerfile

@@ -10,5 +10,4 @@ WORKDIR /app
 COPY --from=build /app .
 EXPOSE 5001
 EXPOSE 5000
-ENV ASPNETCORE_ENVIRONMENT Staging
 ENTRYPOINT ["dotnet", "JOBot.Backend.dll"]

JOBot.Backend/Infrastructure/Config/HeadHunterConfig.cs

@@ -0,0 +1,18 @@
+namespace JOBot.Backend.Infrastructure.Config;
+
+public class HeadHunterConfig
+{
+    public const string SectionName = "HeadHunter";
+    public required HeadHunterLinksConfig Links { get; init; }
+    public required string ClientId { get; init; }
+    public required string Secret { get; init; }
+
+    public class HeadHunterLinksConfig
+    {
+        public required string AuthLink { get; init; }
+        public required string HookDomain { get; init; }
+        public required string HookRoute { get; init; }
+        public required string HeadHunterApiDomain { get; init; }
+        public required string HeadHunterTokenRoute { get; init; }
+    }
+}

JOBot.Backend/JOBot.Backend.csproj

@@ -14,6 +14,7 @@
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 			<PrivateAssets>all</PrivateAssets>
 		</PackageReference>
+		<PackageReference Include="JetBrains.Annotations" Version="2024.3.0" />
 		<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.4">
 		  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		  <PrivateAssets>all</PrivateAssets>

JOBot.Backend/Services/HeadHunterService.cs

@@ -0,0 +1,113 @@
+using System.Text.Json;
+using System.Web;
+using JOBot.Backend.DAL.Context;
+using JOBot.Backend.DTOs.HeadHunterHook;
+using JOBot.Backend.Infrastructure.Config;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+
+namespace JOBot.Backend.Services;
+
+public class HeadHunterService(ILogger<HeadHunterService> logger, IOptions<HeadHunterConfig> config, AppDbContext dbContext)
+{
+    private readonly HeadHunterConfig _config = config.Value;
+
+    /// <summary>
+    /// Generate HeadHunter oauth authorization link
+    /// </summary>
+    /// <param name="userId">Telegram UserId</param>
+    /// <returns>Link for auth</returns>
+    public string GenerateAuthLink(long userId)
+    {
+        
+        return string.Format(_config.Links.AuthLink, [_config.ClientId, GetRedirectUrl(userId)]);
+    }
+
+    public async Task<Status> AuthUser(int userId, string authorizationCode, string? error)
+    {
+        logger.LogInformation($"Authorization for user {userId} in process...");
+        
+        if (!string.IsNullOrEmpty(error))
+        {
+            logger.LogWarning($"User {userId} auth completed with error {error}");
+            return Status.UserAuthRejectedError;
+        }
+
+        using var client = new HttpClient();
+        var form = new Dictionary<string, string>
+        {
+            { "client_id", _config.ClientId },
+            { "client_secret", _config.Secret },
+            { "code", authorizationCode },
+            { "grant_type", "authorization_code" },
+            { "redirect_uri", GetRedirectUrl(userId) }
+        };
+        client.BaseAddress = new UriBuilder(_config.Links.HeadHunterApiDomain)
+        {
+            Port = -1,
+            Scheme = "https"
+        }.Uri;
+        client.DefaultRequestHeaders.UserAgent.ParseAdd("Jobot BackEnd Service");
+
+        using var res = await client.SendAsync(
+            new HttpRequestMessage(
+                HttpMethod.Post,
+                _config.Links.HeadHunterTokenRoute)
+            {
+                Content = new FormUrlEncodedContent(form)
+            });
+
+        if (!res.IsSuccessStatusCode)
+        {
+            logger.LogWarning($"Response of HttpRequest {_config.Links.HeadHunterApiDomain}" +
+                              $"{_config.Links.HeadHunterTokenRoute} has unsuccessful status code {res.StatusCode}");
+            logger.LogWarning($"{res.Content.ReadAsStringAsync().Result}");
+            return Status.HeadHunterAuthRejectedError;
+        }
+        
+        var responseDto = JsonSerializer.Deserialize<HeadHunterTokenResponseDto>(await res.Content.ReadAsStringAsync());
+
+        if (responseDto == null)
+        {
+            logger.LogWarning($"User {userId} auth completed with error " +
+                              $"{nameof(Status.HeadHunterResponseDeserializationFailedError)}");
+            return Status.HeadHunterResponseDeserializationFailedError;
+        }
+        
+        var user = await dbContext.Users.FirstOrDefaultAsync(x => x.UserId == userId);
+
+        if (user == null)
+        {
+            logger.LogWarning($"User {userId} search completed with error {nameof(Status.UserNotFoundError)}");
+            return Status.UserNotFoundError;
+        }
+        
+        user.AccessToken = responseDto.AccessToken;
+        user.RefreshToken = responseDto.RefreshToken;
+        
+        await dbContext.SaveChangesAsync();
+        
+        logger.LogInformation($"User {userId} auth completed!");
+        return Status.Success;
+    }
+
+    private string GetRedirectUrl(long userId)
+    {
+        return new UriBuilder(_config.Links.HookDomain)
+        {
+            Port = -1,
+            Scheme = "https",
+            Path = _config.Links.HookRoute,
+            Query = $"?userId={userId}"
+        }.ToString();
+    }
+
+    public enum Status
+    {
+        UserAuthRejectedError,
+        HeadHunterAuthRejectedError,
+        UserNotFoundError,
+        HeadHunterResponseDeserializationFailedError,
+        Success
+    }
+}

JOBot.Backend/Services/gRPC/UserService.cs

@@ -1,3 +1,4 @@
+using Google.Protobuf.WellKnownTypes;
 using Grpc.Core;
 using JOBot.Backend.DAL.Context;
 using JOBot.Backend.DAL.Models;
@@ -7,7 +8,7 @@ using User = JOBot.Backend.DAL.Models.User;
 
 namespace JOBot.Backend.Services.gRPC;
 
-public class UserService(AppDbContext dbContext) : Proto.User.UserBase
+public class UserService(AppDbContext dbContext, HeadHunterService hhService) : Proto.User.UserBase
 {
     /// <summary>
     /// Create user
@@ -62,6 +63,16 @@ public class UserService(AppDbContext dbContext) : Proto.User.UserBase
         return new AcceptEulaResponse { Success = true };
     }
 
+    public override Task<GetHeadHunterAuthHookResponse> GetHeadHunterAuthHook(
+        GetHeadHunterAuthHookRequest request, 
+        ServerCallContext context)
+    {
+        return Task.Run(() => new GetHeadHunterAuthHookResponse
+        {
+            RegistrationUrl = hhService.GenerateAuthLink(request.UserId)
+        });
+    }
+
     /// <summary>
     /// Throw RPCException if user not found
     /// </summary>

JOBot.Backend/Startup.cs

@@ -1,30 +1,34 @@
 using JOBot.Backend.DAL.Context;
+using JOBot.Backend.Infrastructure.Config;
+using JOBot.Backend.Services;
 using JOBot.Backend.Services.gRPC;
 using Microsoft.EntityFrameworkCore;
 
 namespace JOBot.Backend;
 
-public class Startup
+public class Startup(IConfiguration configuration)
 {
-    public Startup(IConfiguration configuration)
+    private IConfiguration Configuration { get; } = configuration;
-    {
-        Configuration = configuration;
-    }
-
-    public IConfiguration Configuration { get; }
 
     public void ConfigureServices(IServiceCollection services)
     {
         services.AddGrpc(); 
         services.AddGrpcReflection();
+        services.AddControllers();
+        services.AddLogging();
         
         services.AddDbContext<AppDbContext>(options =>
             options.UseNpgsql(Configuration.GetConnectionString("PostgreSQL")));
+
+        services.Configure<HeadHunterConfig>(Configuration.GetSection(HeadHunterConfig.SectionName));
+
+        services.AddScoped<HeadHunterService>();
     }
 
     public void Configure(WebApplication app, IWebHostEnvironment env)
     {
         app.MapGrpcReflectionService().AllowAnonymous();
         app.MapGrpcService<UserService>();
+        app.MapControllers();
     }
 }

JOBot.Backend/appsettings.Staging.json

@@ -1,12 +0,0 @@
-{
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
-    "AllowedHosts": "*",
-    "ConnectionStrings": {
-        "PostgreSQL": "Host=postgres;Port=5432;Database=jobot_test;Username=postgres;Password=LocalDbPass"
-    }
-}

JOBot.Backend/appsettings.json

@@ -9,6 +9,17 @@
     "ConnectionStrings": {
         "PostgreSQL": "Host=postgres;Port=5432;Database=jobot;Username=postgres;Password=LocalDbPass"
     },
+    "HeadHunter": {
+        "Links": {
+            "AuthLink": "https://hh.ru/oauth/authorize?response_type=code&client_id={0}&redirect_uri={1}",
+            "HookDomain": "jobot.lisoveliy.su",
+            "HookRoute": "/auth",
+            "HeadHunterApiDomain": "api.hh.ru",
+            "HeadHunterTokenRoute": "/token"
+        },
+        "ClientId": "",
+        "Secret": ""
+    },
     "Kestrel": {
         "Endpoints": {
             "gRPC": {

JOBot.TClient/ButtonResource.Designer.cs

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace JOBot.TClient {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class ButtonResource {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal ButtonResource() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("JOBot.TClient.ButtonResource", typeof(ButtonResource).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Соглашаюсь с условиями использования ✅.
+        /// </summary>
+        public static string EULAAgrement {
+            get {
+                return ResourceManager.GetString("EULAAgrement", resourceCulture);
+            }
+        }
+    }
+}

JOBot.TClient/ButtonResource.resx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<root>
+    <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+        <xsd:element name="root" msdata:IsDataSet="true">
+            
+        </xsd:element>
+    </xsd:schema>
+    <resheader name="resmimetype">
+        <value>text/microsoft-resx</value>
+    </resheader>
+    <resheader name="version">
+        <value>1.3</value>
+    </resheader>
+    <resheader name="reader">
+        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <resheader name="writer">
+        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <data name="EULAAgrement" xml:space="preserve">
+        <value>Соглашаюсь с условиями использования ✅</value>
+    </data>
+</root>

JOBot.TClient/Commands/Buttons/EulaAgreementButtonCommand.cs

@@ -0,0 +1,18 @@
+using JOBot.Proto;
+using JOBot.TClient.Infrastructure.Attributes.Authorization;
+using JOBot.TClient.Services;
+using JOBot.TClient.Statements;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+
+namespace JOBot.TClient.Commands.Buttons;
+
+[AcceptNotPrepared]
+public class EulaAgreementButtonCommand(PrepareUserState prepareUserState) : IAuthorizedTelegramCommand
+{
+    public async Task ExecuteAsync(Update update, GetUserResponse user, CancellationToken ct)
+    {
+        if (!user.Eula)
+            await prepareUserState.AcceptEula(user, update, ct);
+    }
+}

JOBot.TClient/Commands/Commands/InfoCommand.cs

@@ -0,0 +1,14 @@
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace JOBot.TClient.Commands.Commands;
+
+public class InfoCommand(ITelegramBotClient bot) : ITelegramCommand
+{
+    public async Task ExecuteAsync(Update update, CancellationToken ct)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+        
+        await bot.SendMessage(update.Message.From.Id, TextResource.Info, cancellationToken: ct);
+    }
+}

JOBot.TClient/Commands/Commands/MenuCommand.cs

@@ -0,0 +1,13 @@
+using JOBot.Proto;
+using JOBot.TClient.Services;
+using Telegram.Bot.Types;
+
+namespace JOBot.TClient.Commands.Commands;
+
+public class MenuCommand(MenuService menuService) : IAuthorizedTelegramCommand
+{
+    public async Task ExecuteAsync(Update update, GetUserResponse user, CancellationToken ct)
+    {
+        await menuService.RenderMenu(update, ct);
+    }
+}

JOBot.TClient/Commands/Commands/StartCommand.cs

@@ -0,0 +1,12 @@
+using JOBot.TClient.Statements;
+using Telegram.Bot.Types;
+
+namespace JOBot.TClient.Commands.Commands;
+
+public class StartCommand(PrepareUserState prepareUserState) : ITelegramCommand
+{
+    public async Task ExecuteAsync(Update update, CancellationToken ct)
+    {
+        await prepareUserState.TryToPrepareUser(update, ct);
+    }
+}

JOBot.TClient/Commands/IAuthorizedTelegramCommand.cs

@@ -0,0 +1,17 @@
+using JOBot.Proto;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace JOBot.TClient.Commands;
+
+public interface IAuthorizedTelegramCommand : ITelegramCommand
+{
+    public Task ExecuteAsync(Update update, GetUserResponse user, CancellationToken ct);
+
+    /// <exception cref="UnauthorizedAccessException">Throws if you try to use ITelegramCommand.ExecuteAsync
+    /// instead of IAuthorizedTelegramCommand.ExecuteAsync</exception>
+    Task ITelegramCommand.ExecuteAsync(Update update, CancellationToken ct)
+    {
+        throw new UnauthorizedAccessException("You do not have permission to access this command.");
+    }
+}

JOBot.TClient/Commands/StartCommand.cs

@@ -1,22 +0,0 @@
-using JOBot.TClient.Core.Services;
-using Telegram.Bot;
-using Telegram.Bot.Types;
-
-namespace JOBot.TClient.Commands;
-
-public class StartCommand(ITelegramBotClient bot, UserService userService) : ITelegramCommand
-{
-    private const string ReturnMessage = "Привет! Я JOBot, помощник по поиску работы в IT.";
-    public async Task ExecuteAsync(Update update, CancellationToken ct)
-    {
-        await userService.RegisterAsync(
-            update.Message!.Chat.Id,
-            update.Message.Chat.Username);
-        
-            await bot.SendMessage(chatId: update.Message.Chat.Id,
-                "Продолжая, вы принимаете политику конфиденциальности и правила сервиса" +
-                "\nhttps://hh.ru/article/personal_data?backurl=%2F&role=applicant" +
-                "\nhttps://hh.ru/account/agreement?backurl=%2Faccount%2Fsignup%3Fbackurl%3D%252F%26role%3Dapplicant&role=applicant", 
-                cancellationToken: ct);
-    }
-}

JOBot.TClient/Core/HostedServices/BotBackgroundService.cs

@@ -1,17 +1,22 @@
 using JOBot.TClient.Commands;
+using JOBot.TClient.Commands.Buttons;
+using JOBot.TClient.Commands.Commands;
+using JOBot.TClient.Infrastructure.Attributes.Authorization;
+using JOBot.TClient.Infrastructure.Extensions;
+using JOBot.TClient.Services;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-
-namespace JOBot.TClient.Core.HostedServices;
-
 using Telegram.Bot;
 using Telegram.Bot.Types;
 using Microsoft.Extensions.Hosting;
 
+namespace JOBot.TClient.Core.HostedServices;
+
 public sealed class BotBackgroundService(
     ITelegramBotClient botClient,
     IServiceProvider services,
-    ILogger<BotBackgroundService> logger)
+    ILogger<BotBackgroundService> logger,
+    UserService userService)
     : BackgroundService
 {
     protected override Task ExecuteAsync(CancellationToken stoppingToken)
@@ -29,11 +34,48 @@ public sealed class BotBackgroundService(
         using var scope = services.CreateScope();
         var commands = new Dictionary<string, ITelegramCommand>
         {
-            ["/start"] = scope.ServiceProvider.GetRequiredService<StartCommand>()
+            //Commands
+            ["/start"] = scope.ServiceProvider.GetRequiredService<StartCommand>(),
+            ["/menu"] = scope.ServiceProvider.GetRequiredService<MenuCommand>(),
+            ["/info"] = scope.ServiceProvider.GetRequiredService<InfoCommand>(),
+
+            //Buttons
+            [ButtonResource.EULAAgrement] = scope.ServiceProvider.GetRequiredService<EulaAgreementButtonCommand>(),
         };
 
-        if (update.Message?.Text is { } text && commands.TryGetValue(text, out var command))
+        if (update.Message is { Text: { } text, From: not null })
-            await command.ExecuteAsync(update, ct);
+        {
+            var user = await userService.GetUser(update, ct); //Проверка существования пользователя
+
+            if (user == null)
+            {
+                await commands["/start"].ExecuteAsync(update, ct);
+                return;
+            }
+
+            if (commands.TryGetValue(text, out var command))
+            {
+                if (command is IAuthorizedTelegramCommand authorizedTelegramCommand)
+                {
+                    var attribute = Attribute.GetCustomAttribute(
+                        command.GetType(),
+                        typeof(AcceptNotPreparedAttribute));
+                    if (!user.IsPrepared() && attribute is not AcceptNotPreparedAttribute)
+                    {
+                        await commands["/start"].ExecuteAsync(update, ct);
+                        //заставляем пользователя завершить регистрацию
+                        return;
+                    }
+
+                    await authorizedTelegramCommand.ExecuteAsync(update, user, ct);
+                }
+                else await command.ExecuteAsync(update, ct);
+
+                return;
+            }
+
+            await bot.SendMessage(update.Message.From.Id, TextResource.CommandNotFound, cancellationToken: ct);
+        }
     }
 
     private Task HandleErrorAsync(ITelegramBotClient bot, Exception ex, CancellationToken ct)

JOBot.TClient/Core/Services/UserService.cs

@@ -1,18 +0,0 @@
-using User = JOBot.Proto.User;
-
-namespace JOBot.TClient.Core.Services;
-
-public class UserService(User.UserClient client)
-{
-    public async Task<bool> RegisterAsync(long userId, string? username)
-    {
-        
-        var response = await client.RegisterAsync(new()
-        {
-            UserId = userId, 
-            Username = username
-        });
-
-        return response.Success;
-    }
-}

JOBot.TClient/DependencyInjection.cs

@@ -1,8 +1,11 @@
 using Grpc.Core;
 using Grpc.Net.Client;
 using JOBot.Proto;
-using JOBot.TClient.Commands;
+using JOBot.TClient.Commands.Buttons;
-using JOBot.TClient.Core.Services;
+using JOBot.TClient.Commands.Commands;
+using JOBot.TClient.Core.HostedServices;
+using JOBot.TClient.Services;
+using JOBot.TClient.Statements;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -19,15 +22,31 @@ public static class DependencyInjection
         services.AddScoped<ChannelBase, GrpcChannel>(_ => GrpcChannel.ForAddress(config.GetValue<string>("BackendHost") 
                                                                     ?? throw new MissingFieldException("Host is not defined")));
         
-        //Commands
+        #region Commands
         services.AddScoped<StartCommand>();
+        services.AddScoped<MenuCommand>();
+        services.AddScoped<InfoCommand>();
         
+        //buttons
+        services.AddScoped<EulaAgreementButtonCommand>();
+        #endregion
+        
+        #region gRPC Clients
+        services.AddGrpcClient<User.UserClient>(o => o.Address = new Uri("http://backend:5001"));
+        #endregion
+        
+        #region Services
         services.AddSingleton<UserService>();
+        services.AddScoped<PrepareUserService>();
+        services.AddScoped<MenuService>();
+        #endregion
         
-        //gRPC Clients
+        #region States
-        services.AddScoped<User.UserClient>();
+        services.AddScoped<PrepareUserState>();
+        #endregion
         
-        // Telegram Bot
+        // Bot service
+        services.AddHostedService<BotBackgroundService>();
         services.AddSingleton<ITelegramBotClient>(_ => 
             new TelegramBotClient(config.GetValue<string>("TelegramToken") 
                                   ?? throw new MissingFieldException("TelegramToken is not set")));

JOBot.TClient/Infrastructure/Attributes/Authorization/AcceptNotPreparedAttribute.cs

@@ -0,0 +1,4 @@
+namespace JOBot.TClient.Infrastructure.Attributes.Authorization;
+
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
+public class AcceptNotPreparedAttribute : Attribute;

JOBot.TClient/Infrastructure/Exceptions/FallbackException.cs

@@ -0,0 +1,17 @@
+using Telegram.Bot;
+using Telegram.Bot.Types;
+
+namespace JOBot.TClient.Infrastructure.Exceptions;
+
+/// <summary>
+/// Exception for fallback
+/// WARNING: Don't create new exception without throwing it
+/// </summary>
+public class FallbackException : Exception
+{
+    public FallbackException(string message, Message botMessage, ITelegramBotClient botClient) : base(message)
+    {
+        botClient.SendMessage(chatId: botMessage.Chat.Id,
+            TextResource.FallbackMessage);
+    }
+}

JOBot.TClient/Infrastructure/Extensions/GRpcModelsExtensions.cs

@@ -0,0 +1,9 @@
+using JOBot.Proto;
+
+namespace JOBot.TClient.Infrastructure.Extensions;
+
+public static class GRpcModelsExtensions
+{
+    public static bool IsPrepared(this GetUserResponse user) => user is { Eula: true, IsLogged: true } &&
+                                                                !string.IsNullOrEmpty(user.CVUrl);
+}

JOBot.TClient/JOBot.TClient.csproj

@@ -8,18 +8,19 @@
     </PropertyGroup>
 
     <ItemGroup>
-		<PackageReference Include="Google.Protobuf" Version="3.30.2" />
+        <PackageReference Include="Google.Protobuf" Version="3.30.2"/>
-		<PackageReference Include="Grpc.Net.Client" Version="2.71.0" />
+        <PackageReference Include="Grpc.Net.Client" Version="2.71.0"/>
-		<PackageReference Include="Grpc.Net.ClientFactory" Version="2.71.0" />
+        <PackageReference Include="Grpc.Net.ClientFactory" Version="2.71.0"/>
         <PackageReference Include="Grpc.Tools" Version="2.71.0">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-		<PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.4" />
+        <PackageReference Include="JetBrains.Annotations" Version="2024.3.0"/>
-		<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.4" />
+        <PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.4"/>
-		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.4" />
+        <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="9.0.4"/>
-		<PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.4" />
+        <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.4"/>
-		<PackageReference Include="Telegram.Bot" Version="22.5.1" />
+        <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.4"/>
+        <PackageReference Include="Telegram.Bot" Version="22.5.1"/>
     </ItemGroup>
 
     <ItemGroup>
@@ -33,7 +34,33 @@
     </ItemGroup>
 
     <ItemGroup>
-	  <Folder Include="Infrastucture\" />
+        <Compile Update="ButtonResource.Designer.cs">
+            <DesignTime>True</DesignTime>
+            <AutoGen>True</AutoGen>
+            <DependentUpon>ButtonResource.resx</DependentUpon>
+        </Compile>
+        <Compile Update="TextResource.Designer.cs">
+            <DesignTime>True</DesignTime>
+            <AutoGen>True</AutoGen>
+            <DependentUpon>TextResource.resx</DependentUpon>
+        </Compile>
+    </ItemGroup>
+
+    <ItemGroup>
+        <EmbeddedResource Update="TextResource.resx">
+            <Generator>PublicResXFileCodeGenerator</Generator>
+            <LastGenOutput>TextResource.Designer.cs</LastGenOutput>
+        </EmbeddedResource>
+        <EmbeddedResource Update="ButtonResource.resx">
+            <Generator>PublicResXFileCodeGenerator</Generator>
+            <LastGenOutput>ButtonResource.Designer.cs</LastGenOutput>
+        </EmbeddedResource>
+    </ItemGroup>
+
+    <ItemGroup>
+      <Content Include="appsettings.json">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </Content>
     </ItemGroup>
 
 </Project>

JOBot.TClient/Program.cs

@@ -1,9 +1,4 @@
-using JOBot.Proto;
+using JOBot.TClient;
-using JOBot.TClient;
-using JOBot.TClient.Commands;
-using JOBot.TClient.Core.HostedServices;
-using JOBot.TClient.Core.Services;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 var host = Host.CreateDefaultBuilder(args)
@@ -12,12 +7,6 @@ var host = Host.CreateDefaultBuilder(args)
         // Настройка DI
         services.ConfigureServices(context.Configuration);
         
-        // Фоновый сервис для бота
-        services.AddHostedService<BotBackgroundService>();
-
-        services.AddScoped<StartCommand>();
-        services.AddSingleton<UserService>();
-        services.AddGrpcClient<User.UserClient>(o => o.Address = new Uri("http://backend:5001"));
     })
     .Build();
 

JOBot.TClient/Services/MenuService.cs

@@ -0,0 +1,15 @@
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using User = JOBot.Proto.User;
+
+namespace JOBot.TClient.Services;
+
+public class MenuService(ITelegramBotClient bot)
+{
+    public async Task RenderMenu(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+        
+        await bot.SendMessage(update.Message.From.Id,"PrepareUser stage is done.", cancellationToken: ct);
+    }
+}

JOBot.TClient/Services/PrepareUserService.cs

@@ -0,0 +1,101 @@
+using JOBot.Proto;
+using JOBot.TClient.Infrastructure.Exceptions;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using User = JOBot.Proto.User;
+
+namespace JOBot.TClient.Services;
+
+public class PrepareUserService(ITelegramBotClient bot, User.UserClient userClient) : UserService(bot, userClient)
+{
+    private readonly ITelegramBotClient _bot = bot;
+    private readonly User.UserClient _userClient = userClient;
+
+    /// <summary>
+    /// Get or register user on system
+    /// </summary>
+    /// <param name="update">Telegram Update object</param>
+    /// <param name="ct">Cancellation Token</param>
+    /// <returns>RPC User Response</returns>
+    /// <exception cref="FallbackException">If something in server logic went wrong</exception>
+    /// <exception cref="ArgumentNullException">If update.Message is null</exception>
+    public async Task<GetUserResponse> RegisterUser(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+
+        var result = await _userClient.RegisterAsync(new RegisterRequest
+        {
+            UserId = update.Message.From.Id,
+            Username = update.Message.From.Username,
+        });
+
+        if (!result.Success)
+        {
+            await _bot.SendMessage(chatId: update.Message.Chat.Id,
+                TextResource.FallbackMessage,
+                cancellationToken: ct);
+
+            throw new FallbackException(TextResource.FallbackMessage, update.Message, _bot);
+        }
+
+        var user = await _userClient.GetUserAsync(new GetUserRequest()
+        {
+            UserId = update.Message.From.Id,
+        });
+
+        if (user == null)
+            throw new FallbackException(TextResource.FallbackMessage, update.Message, _bot);
+
+        return user;
+    }
+
+    /// <summary>
+    /// Get Eula Agreement from user
+    /// </summary>
+    /// <param name="update">Telegram Update object</param>
+    /// <param name="ct">Cancellation Token</param>
+    /// <exception cref="ArgumentNullException">If update.Message is null</exception>
+    public async Task AskForEulaAgreement(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+
+        await _bot.SendMessage(
+            update.Message.From.Id,
+            TextResource.EULA,
+            replyMarkup: new[] { ButtonResource.EULAAgrement }, cancellationToken: ct);
+    }
+
+    /// <summary>
+    /// Accept EULA for user
+    /// </summary>
+    /// <param name="update">Telegram update object</param>
+    /// <param name="ct">Cancellation Token</param>
+    /// <exception cref="FallbackException">If something in server logic went wrong</exception>
+    public async Task AcceptEula(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+        var result = await _userClient.AcceptEulaAsync(new()
+        {
+            EulaAccepted = true,
+            UserId = update.Message.From.Id,
+        });
+
+        if (!result.Success)
+            throw new FallbackException(TextResource.FallbackMessage, update.Message, _bot);
+    }
+
+    public async Task Auth(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+        
+        var url = await _userClient.GetHeadHunterAuthHookAsync(new GetHeadHunterAuthHookRequest()
+        {
+            UserId = update.Message.From.Id
+        });
+
+        await _bot.SendMessage(
+            update.Message.From.Id, 
+            string.Format(TextResource.AskForAuth, [url.RegistrationUrl]), 
+            cancellationToken: ct);
+    }
+}

JOBot.TClient/Services/UserService.cs

@@ -0,0 +1,41 @@
+using Grpc.Core;
+using JOBot.Proto;
+using JOBot.TClient.Infrastructure.Exceptions;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using User = JOBot.Proto.User;
+
+namespace JOBot.TClient.Services;
+
+public class UserService(ITelegramBotClient bot, User.UserClient userClient)
+{
+    /// <summary>
+    /// Get user
+    /// </summary>
+    /// <param name="update">Telegram Update object</param>
+    /// <param name="ct">Cancellation Token</param>
+    /// <returns>RPC User Response or null if user not exists</returns>
+    /// <exception cref="FallbackException">If something in server logic went wrong</exception>
+    /// <exception cref="ArgumentNullException">If update.Message is null</exception>
+    public async Task<GetUserResponse?> GetUser(Update update, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(update.Message?.From);
+
+        GetUserResponse? user;
+        try
+        {
+            user = await userClient.GetUserAsync(new GetUserRequest() //Получаем пользователя
+            {
+                UserId = update.Message.From.Id,
+            });
+        }
+        catch (RpcException e) //Пользователь не найден?
+        {
+            if (e.StatusCode != StatusCode.NotFound)
+                throw new FallbackException(TextResource.FallbackMessage, update.Message, bot);
+
+            return null;
+        }
+        return user;
+    }
+}

JOBot.TClient/Statements/PrepareUserState.cs

@@ -0,0 +1,55 @@
+using JOBot.Proto;
+using JOBot.TClient.Services;
+using Telegram.Bot.Types;
+using User = JOBot.Proto.User;
+
+namespace JOBot.TClient.Statements;
+
+public class PrepareUserState(PrepareUserService prepareUserService, MenuService menuService)
+{
+    /// <summary>
+    /// Try to prepare user if is not registered
+    /// </summary>
+    /// <param name="update">Update telegram object</param>
+    /// <param name="ct">Cancellation token</param>
+    public async Task TryToPrepareUser(Update update, CancellationToken ct = default)
+    {
+        var user = await prepareUserService.GetUser(update, ct) ?? await prepareUserService.RegisterUser(update, ct);
+
+        if (!user.Eula)
+        {
+            await prepareUserService.AskForEulaAgreement(update, ct);
+            return; //interrupt while eula isn't accepted
+        }
+        
+        await OnUserEulaValidStage(user, update, ct);
+    }
+
+    /// <summary>
+    /// Signal for accepted eula
+    /// </summary>
+    /// <param name="user"></param>
+    /// <param name="update"></param>
+    /// <param name="ct"></param>
+    public async Task AcceptEula(GetUserResponse user, Update update, CancellationToken ct = default)
+    {
+        await prepareUserService.AcceptEula(update, ct: ct);
+        await OnUserEulaValidStage(user, update, ct);
+    }
+
+    /// <summary>
+    /// Continue prepare stage
+    /// </summary>
+    /// <param name="user"></param>
+    /// <param name="update"></param>
+    /// <param name="ct"></param>
+    private async Task OnUserEulaValidStage(GetUserResponse user, Update update, CancellationToken ct = default)
+    {
+        if (!user.IsLogged)
+        {
+            await prepareUserService.Auth(update, ct);
+            return;
+        }
+        await menuService.RenderMenu(update, ct); //boilerplate
+    }
+}

JOBot.TClient/TextResource.Designer.cs

@@ -0,0 +1,111 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace JOBot.TClient {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    public class TextResource {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal TextResource() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("JOBot.TClient.TextResource", typeof(TextResource).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Авторизируйтесь на сайте HeadHunter для получения доступа к резюме и вакансиям {0}.
+        /// </summary>
+        public static string AskForAuth {
+            get {
+                return ResourceManager.GetString("AskForAuth", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Команда не найдена, попробуйте что-то другое.
+        /// </summary>
+        public static string CommandNotFound {
+            get {
+                return ResourceManager.GetString("CommandNotFound", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Продолжая, вы принимаете политику конфиденциальности и правила сервиса
+        ///
+        ///https://hh.ru/article/personal_data?backurl=%2F&amp;role=applicant 
+        ///
+        ///https://hh.ru/account/agreement?backurl=%2Faccount%2Fsignup%3Fbackurl%3D%252F%26role%3Dapplicant&amp;role=applicant&quot;.
+        /// </summary>
+        public static string EULA {
+            get {
+                return ResourceManager.GetString("EULA", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Something went REALLY wrong. Service can&apos;t continue process..
+        /// </summary>
+        public static string FallbackMessage {
+            get {
+                return ResourceManager.GetString("FallbackMessage", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Это бот для упрощения поиска работы на HH.ru.
+        /// </summary>
+        public static string Info {
+            get {
+                return ResourceManager.GetString("Info", resourceCulture);
+            }
+        }
+    }
+}

JOBot.TClient/TextResource.resx

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<root>
+    <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+        <xsd:element name="root" msdata:IsDataSet="true">
+            
+        </xsd:element>
+    </xsd:schema>
+    <resheader name="resmimetype">
+        <value>text/microsoft-resx</value>
+    </resheader>
+    <resheader name="version">
+        <value>1.3</value>
+    </resheader>
+    <resheader name="reader">
+        <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <resheader name="writer">
+        <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+    </resheader>
+    <data name="EULA" xml:space="preserve">
+        <value>Продолжая, вы принимаете политику конфиденциальности и правила сервиса
+
+https://hh.ru/article/personal_data?backurl=%2F&amp;role=applicant 
+
+https://hh.ru/account/agreement?backurl=%2Faccount%2Fsignup%3Fbackurl%3D%252F%26role%3Dapplicant&amp;role=applicant"</value>
+    </data>
+    <data name="FallbackMessage" xml:space="preserve">
+        <value>Something went REALLY wrong. Service can't continue process.</value>
+    </data>
+    <data name="CommandNotFound" xml:space="preserve">
+        <value>Команда не найдена, попробуйте что-то другое</value>
+    </data>
+    <data name="Info" xml:space="preserve">
+        <value>Это бот для упрощения поиска работы на HH.ru</value>
+    </data>
+    <data name="AskForAuth" xml:space="preserve">
+        <value>Авторизируйтесь на сайте HeadHunter для получения доступа к резюме и вакансиям {0}</value>
+    </data>
+</root>

Proto/user.proto

@@ -1,14 +1,16 @@
 syntax = "proto3";
 option csharp_namespace = "JOBot.Proto";
 
+import "google/protobuf/wrappers.proto";
+import "google/protobuf/empty.proto";
+
 service User {
 	rpc Register (RegisterRequest) returns (RegisterResponse);
 	rpc GetUser (GetUserRequest) returns (GetUserResponse);
 	rpc AcceptEula (AcceptEulaRequest) returns (AcceptEulaResponse);
+	rpc GetHeadHunterAuthHook(GetHeadHunterAuthHookRequest) returns (GetHeadHunterAuthHookResponse);
 }
 
-import "google/protobuf/wrappers.proto";
-
 message RegisterRequest{
 	int64 user_id = 1;
 	google.protobuf.StringValue username = 2;
@@ -38,3 +40,11 @@ message AcceptEulaRequest {
 message AcceptEulaResponse{
 	bool success = 1;
 }
+
+message GetHeadHunterAuthHookRequest{
+	int64 user_id = 1;
+}
+
+message GetHeadHunterAuthHookResponse{
+	string registration_url = 1;
+}

README.md

@@ -5,21 +5,28 @@ Telegram-бот для автоматизации поиска работы че
 
 ## 🔥 Возможности
 
-- **Авторизация через HH**  
   Привяжите аккаунт HeadHunter для доступа к резюме и вакансиям.
+
+- **Отклик по предпочтениям**
+
+  Выбор откликаемых вакансий по предпочтениям.
 - **Умные отклики**
+
   Автоматическая отправка откликов на подходящие вакансии.
 - **Проверка резюме**
-  Уведомления, если резюме требует обновления.
+
+  Правка резюме, под ваши приоритеты.
 - **Аналитика**  
+
   Статистика по откликам и приглашениям.
 
 ## 🛠 Технологии
 
 - **Backend**: .NET 8 + gRPC
-- **База данных**: PostgreSQL  
+- **Frontend** Telegram клиент через Telegram.Bot
-- **Авторизация**: OAuth 2.0 (HH API)  
+- **БД**: PostgreSQL
-- **Инфраструктура**: Docker + Kubernetes (опционально)
+- **Авторизация**: OAuth 2.0 (HH API), Telegram API 
+- **Инфраструктура**: Docker / Docker compose
 
 ## 🚀 Запуск
 
@@ -33,24 +40,15 @@ Telegram-бот для автоматизации поиска работы че
 
 ### 2. Запуск через Docker
 ```
-docker-compose up -d
+docker-compose up -d --build
-dotnet run --project JoBot.Backend
-dotnet run --project JoBot.Client
 ```
 
 ## 📌 Команды бота
 |Команда|Описание|
 |-------|--------|
 |/start	|Начало работы|
-|/connect_hh|Привязать аккаунт HH|
+|/menu|Настройка откликов и резюме по предпочтениям|
-|/jobs	 |Поиск вакансий|
+|/info|Информация о боте|
-|/profile|Проверить резюме|
-|/stats  |Статистика откликов|
-
-## 🔒 Безопасность
-Токены пользователей шифруются (AES-256)
-
-Все данные передаются через HTTPS
 
 📄 Лицензия
 MIT License. Подробнее в файле LICENSE.

compose.dev.yml

@@ -9,7 +9,7 @@ services:
     ports:
       - "5432:5432"
     volumes:
-      - ./.docker/postgres_data:/var/lib/postgresql/data
+      - postgres_data:/var/lib/postgresql/data
     networks:
       - jobot
   
@@ -20,6 +20,7 @@ services:
     depends_on:
       - postgres
     ports:
+      - "5000:5000"
       - "5001:5001"
     networks:
       - jobot
@@ -35,3 +36,6 @@ services:
 
 networks:
   jobot:
+    
+volumes:
+  postgres_data:

compose.yml

@@ -7,7 +7,7 @@ services:
       POSTGRES_PASSWORD: LocalDbPass
       POSTGRES_DB: jobot  
     volumes:
-      - ./.docker/postgres_data:/var/lib/postgresql/data
+      - postgres_data:/var/lib/postgresql/data
     networks:
       - jobot
   
@@ -17,6 +17,8 @@ services:
       dockerfile: JOBot.Backend/Dockerfile
     depends_on:
       - postgres
+    ports:
+      - "5000:5000"
     networks:
       - jobot
   
@@ -31,3 +33,7 @@ services:
 
 networks:
   jobot:
+    
+
+volumes:
+  postgres_data: