Add Telegram bot integration and enhance user management features

- Introduced Telegram.Bot package for bot functionality.
- Updated user management to include Telegram linking and blocking features.
- Enhanced activation request handling with notifications via Telegram.
- Added new database entities for Telegram link tokens and login requests.
- Implemented traffic synchronization for client stats in the XuiPanelGateway.
- Updated application structure to support new test projects and improved dependency injection for Telegram services.
This commit is contained in:
Leonid Pershin
2026-07-02 01:01:03 +03:00
parent 1a8d33efa3
commit 7b6fe9ad78
142 changed files with 7570 additions and 22 deletions
@@ -0,0 +1,113 @@
using NSubstitute;
using PnvPanel.Application.Common.Interfaces;
using PnvPanel.Application.Telegram;
using PnvPanel.Application.Telegram.Bot;
using PnvPanel.Application.Tests.TestSupport;
using PnvPanel.Domain.Telegram;
using Xunit;
namespace PnvPanel.Application.Tests.Telegram.Bot;
public class ApproveTelegramLoginCommandHandlerTests
{
private readonly IIdentityService _identityService = Substitute.For<IIdentityService>();
[Fact]
public async Task Handle_WhenPendingRequestAndLinkedUser_ApprovesRequest()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new ApproveTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new ApproveTelegramLoginCommand(request.Id, telegramUserId), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(TelegramLoginStatus.Approved, request.Status);
Assert.Equal(userId, request.UserId);
}
[Fact]
public async Task Handle_WhenTelegramUserNotLinked_ReturnsNotLinked()
{
using var dbContext = InMemoryDbContextFactory.Create();
const long telegramUserId = 123456L;
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>())
.Returns((Guid?)null);
var handler = new ApproveTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new ApproveTelegramLoginCommand(Guid.NewGuid(), telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.NotLinked, result.Error);
}
[Fact]
public async Task Handle_WhenLoginRequestNotFound_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new ApproveTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new ApproveTelegramLoginCommand(Guid.NewGuid(), telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.LoginRequestNotFound, result.Error);
}
[Fact]
public async Task Handle_WhenRequestAlreadyDecided_ReturnsConflict()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
request.Reject();
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new ApproveTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new ApproveTelegramLoginCommand(request.Id, telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal("Telegram.LoginRequestInvalid", result.Error.Code);
}
[Fact]
public async Task Handle_WhenRequestExpired_ReturnsConflict()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(-5), null);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new ApproveTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new ApproveTelegramLoginCommand(request.Id, telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal("Telegram.LoginRequestInvalid", result.Error.Code);
}
}
@@ -0,0 +1,108 @@
using NSubstitute;
using PnvPanel.Application.Common.Interfaces;
using PnvPanel.Application.Common.Models;
using PnvPanel.Application.Telegram;
using PnvPanel.Application.Telegram.Bot;
using PnvPanel.Application.Tests.TestSupport;
using PnvPanel.Domain.Telegram;
using Xunit;
namespace PnvPanel.Application.Tests.Telegram.Bot;
public class LinkTelegramCommandHandlerTests
{
private readonly IIdentityService _identityService = Substitute.For<IIdentityService>();
[Fact]
public async Task Handle_WhenTokenValid_LinksUserAndConsumesToken()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var token = TelegramLinkToken.Create(userId, TimeSpan.FromMinutes(5));
dbContext.TelegramLinkTokens.Add(token);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.LinkTelegramAsync(userId, 123456L, "alice_tg", Arg.Any<CancellationToken>())
.Returns(Result.Success());
var handler = new LinkTelegramCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new LinkTelegramCommand(token.Token, 123456L, "alice_tg"), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(userId, result.Value);
Assert.False(token.IsValid);
}
[Fact]
public async Task Handle_WhenTokenNotFound_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var handler = new LinkTelegramCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new LinkTelegramCommand("missing-token", 123456L, null), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.LinkTokenNotFound, result.Error);
}
[Fact]
public async Task Handle_WhenTokenAlreadyConsumed_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var token = TelegramLinkToken.Create(userId, TimeSpan.FromMinutes(5));
token.Consume();
dbContext.TelegramLinkTokens.Add(token);
await dbContext.SaveChangesAsync(CancellationToken.None);
var handler = new LinkTelegramCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new LinkTelegramCommand(token.Token, 123456L, null), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.LinkTokenNotFound, result.Error);
await _identityService.DidNotReceive().LinkTelegramAsync(
Arg.Any<Guid>(), Arg.Any<long>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Handle_WhenTokenExpired_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var token = TelegramLinkToken.Create(userId, TimeSpan.FromMinutes(-5));
dbContext.TelegramLinkTokens.Add(token);
await dbContext.SaveChangesAsync(CancellationToken.None);
var handler = new LinkTelegramCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new LinkTelegramCommand(token.Token, 123456L, null), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.LinkTokenNotFound, result.Error);
}
[Fact]
public async Task Handle_WhenIdentityServiceFails_ReturnsFailureWithoutConsumingToken()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var token = TelegramLinkToken.Create(userId, TimeSpan.FromMinutes(5));
dbContext.TelegramLinkTokens.Add(token);
await dbContext.SaveChangesAsync(CancellationToken.None);
var error = Error.Conflict("Telegram.AlreadyLinked", "Этот Telegram уже привязан к другому аккаунту.");
_identityService.LinkTelegramAsync(userId, 123456L, null, Arg.Any<CancellationToken>())
.Returns(Result.Failure(error));
var handler = new LinkTelegramCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new LinkTelegramCommand(token.Token, 123456L, null), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(error, result.Error);
Assert.True(token.IsValid);
}
}
@@ -0,0 +1,91 @@
using NSubstitute;
using PnvPanel.Application.Common.Interfaces;
using PnvPanel.Application.Telegram;
using PnvPanel.Application.Telegram.Bot;
using PnvPanel.Application.Tests.TestSupport;
using PnvPanel.Domain.Telegram;
using Xunit;
namespace PnvPanel.Application.Tests.Telegram.Bot;
public class RejectTelegramLoginCommandHandlerTests
{
private readonly IIdentityService _identityService = Substitute.For<IIdentityService>();
[Fact]
public async Task Handle_WhenPendingRequestAndLinkedUser_RejectsRequest()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new RejectTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new RejectTelegramLoginCommand(request.Id, telegramUserId), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(TelegramLoginStatus.Rejected, request.Status);
}
[Fact]
public async Task Handle_WhenTelegramUserNotLinked_ReturnsNotLinked()
{
using var dbContext = InMemoryDbContextFactory.Create();
const long telegramUserId = 123456L;
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>())
.Returns((Guid?)null);
var handler = new RejectTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new RejectTelegramLoginCommand(Guid.NewGuid(), telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.NotLinked, result.Error);
}
[Fact]
public async Task Handle_WhenLoginRequestNotFound_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new RejectTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new RejectTelegramLoginCommand(Guid.NewGuid(), telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramErrors.LoginRequestNotFound, result.Error);
}
[Fact]
public async Task Handle_WhenRequestAlreadyDecided_ReturnsConflict()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
const long telegramUserId = 123456L;
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
request.Approve(userId);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.FindUserIdByTelegramUserIdAsync(telegramUserId, Arg.Any<CancellationToken>()).Returns(userId);
var handler = new RejectTelegramLoginCommandHandler(dbContext, _identityService);
var result = await handler.Handle(new RejectTelegramLoginCommand(request.Id, telegramUserId), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal("Telegram.LoginRequestInvalid", result.Error.Code);
}
}
@@ -0,0 +1,40 @@
using PnvPanel.Application.Auth;
using PnvPanel.Application.Telegram;
using PnvPanel.Application.Tests.TestSupport;
using Xunit;
namespace PnvPanel.Application.Tests.Telegram;
public class CreateLinkTokenCommandHandlerTests
{
[Fact]
public async Task Handle_WhenAuthenticated_CreatesTokenAndAddsToDbContext()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var handler = new CreateLinkTokenCommandHandler(dbContext, FakeCurrentUser.Authenticated(userId));
var result = await handler.Handle(new CreateLinkTokenCommand(), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.False(string.IsNullOrEmpty(result.Value.Token));
Assert.True(result.Value.ExpiresAt > DateTimeOffset.UtcNow);
Assert.Single(dbContext.TelegramLinkTokens.Local);
Assert.Equal(userId, dbContext.TelegramLinkTokens.Local.Single().UserId);
}
[Fact]
public async Task Handle_WhenNotAuthenticated_ReturnsUnauthorized()
{
using var dbContext = InMemoryDbContextFactory.Create();
var handler = new CreateLinkTokenCommandHandler(dbContext, FakeCurrentUser.Anonymous());
var result = await handler.Handle(new CreateLinkTokenCommand(), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(AuthErrors.Unauthorized, result.Error);
Assert.Empty(dbContext.TelegramLinkTokens.Local);
}
}
@@ -0,0 +1,116 @@
using NSubstitute;
using PnvPanel.Application.Auth;
using PnvPanel.Application.Common.Interfaces;
using PnvPanel.Application.Tests.TestSupport;
using PnvPanel.Domain.Telegram;
using Xunit;
using TelegramNs = PnvPanel.Application.Telegram;
namespace PnvPanel.Application.Tests.Telegram;
public class GetLoginRequestStatusQueryHandlerTests
{
private readonly IIdentityService _identityService = Substitute.For<IIdentityService>();
private readonly IJwtTokenService _jwtTokenService = Substitute.For<IJwtTokenService>();
private readonly IRefreshTokenService _refreshTokenService = Substitute.For<IRefreshTokenService>();
private TelegramNs.GetLoginRequestStatusQueryHandler CreateHandler(PnvPanel.Infrastructure.Persistence.AppDbContext dbContext)
=> new(dbContext, _identityService, _jwtTokenService, _refreshTokenService);
[Fact]
public async Task Handle_WhenRequestNotFound_ReturnsNotFound()
{
using var dbContext = InMemoryDbContextFactory.Create();
var handler = CreateHandler(dbContext);
var result = await handler.Handle(new TelegramNs.GetLoginRequestStatusQuery(Guid.NewGuid()), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(TelegramNs.TelegramErrors.LoginRequestNotFound, result.Error);
}
[Fact]
public async Task Handle_WhenPendingAndExpired_ReturnsExpiredStatusWithoutIssuingTokens()
{
using var dbContext = InMemoryDbContextFactory.Create();
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(-5), null);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
var handler = CreateHandler(dbContext);
var result = await handler.Handle(new TelegramNs.GetLoginRequestStatusQuery(request.Id), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(TelegramLoginStatus.Expired, result.Value.Status);
Assert.Null(result.Value.Auth);
await _refreshTokenService.DidNotReceive().IssueAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Handle_WhenStillPending_ReturnsPendingStatusWithoutAuth()
{
using var dbContext = InMemoryDbContextFactory.Create();
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
var handler = CreateHandler(dbContext);
var result = await handler.Handle(new TelegramNs.GetLoginRequestStatusQuery(request.Id), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(TelegramLoginStatus.Pending, result.Value.Status);
Assert.Null(result.Value.Auth);
}
[Fact]
public async Task Handle_WhenApproved_ConsumesRequestAndReturnsAuthResult()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
request.Approve(userId);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
var profile = new CurrentUserProfile(userId, "alice", Guid.NewGuid(), "user", true, false, 3);
_identityService.GetProfileAsync(userId, Arg.Any<CancellationToken>()).Returns(profile);
_jwtTokenService.GenerateAccessToken(Arg.Any<AuthenticatedUser>())
.Returns(("access-token", DateTimeOffset.UtcNow.AddMinutes(15)));
_refreshTokenService.IssueAsync(userId, Arg.Any<CancellationToken>())
.Returns(new IssuedRefreshToken("refresh-token", DateTimeOffset.UtcNow.AddDays(30)));
var handler = CreateHandler(dbContext);
var result = await handler.Handle(new TelegramNs.GetLoginRequestStatusQuery(request.Id), CancellationToken.None);
Assert.True(result.IsSuccess);
Assert.Equal(TelegramLoginStatus.Approved, result.Value.Status);
Assert.NotNull(result.Value.Auth);
Assert.Equal("access-token", result.Value.Auth!.AccessToken);
Assert.True(result.Value.Auth.User.TelegramLinked);
Assert.Equal(TelegramLoginStatus.Consumed, request.Status);
}
[Fact]
public async Task Handle_WhenApprovedButProfileMissing_ReturnsUnauthorized()
{
using var dbContext = InMemoryDbContextFactory.Create();
var userId = Guid.NewGuid();
var request = TelegramLoginRequest.Create(TimeSpan.FromMinutes(5), null);
request.Approve(userId);
dbContext.TelegramLoginRequests.Add(request);
await dbContext.SaveChangesAsync(CancellationToken.None);
_identityService.GetProfileAsync(userId, Arg.Any<CancellationToken>()).Returns((CurrentUserProfile?)null);
var handler = CreateHandler(dbContext);
var result = await handler.Handle(new TelegramNs.GetLoginRequestStatusQuery(request.Id), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(AuthErrors.Unauthorized, result.Error);
}
}
@@ -0,0 +1,55 @@
using NSubstitute;
using PnvPanel.Application.Auth;
using PnvPanel.Application.Common.Interfaces;
using PnvPanel.Application.Common.Models;
using PnvPanel.Application.Telegram;
using PnvPanel.Application.Tests.TestSupport;
using Xunit;
namespace PnvPanel.Application.Tests.Telegram;
public class UnlinkTelegramCommandHandlerTests
{
private readonly IIdentityService _identityService = Substitute.For<IIdentityService>();
[Fact]
public async Task Handle_WhenAuthenticated_DelegatesToIdentityService()
{
var userId = Guid.NewGuid();
_identityService.UnlinkTelegramAsync(userId, Arg.Any<CancellationToken>()).Returns(Result.Success());
var handler = new UnlinkTelegramCommandHandler(_identityService, FakeCurrentUser.Authenticated(userId));
var result = await handler.Handle(new UnlinkTelegramCommand(), CancellationToken.None);
Assert.True(result.IsSuccess);
await _identityService.Received(1).UnlinkTelegramAsync(userId, Arg.Any<CancellationToken>());
}
[Fact]
public async Task Handle_WhenNotAuthenticated_ReturnsUnauthorized()
{
var handler = new UnlinkTelegramCommandHandler(_identityService, FakeCurrentUser.Anonymous());
var result = await handler.Handle(new UnlinkTelegramCommand(), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(AuthErrors.Unauthorized, result.Error);
await _identityService.DidNotReceive().UnlinkTelegramAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task Handle_WhenIdentityServiceFails_PropagatesFailure()
{
var userId = Guid.NewGuid();
var error = TelegramErrors.NotLinked;
_identityService.UnlinkTelegramAsync(userId, Arg.Any<CancellationToken>()).Returns(Result.Failure(error));
var handler = new UnlinkTelegramCommandHandler(_identityService, FakeCurrentUser.Authenticated(userId));
var result = await handler.Handle(new UnlinkTelegramCommand(), CancellationToken.None);
Assert.False(result.IsSuccess);
Assert.Equal(error, result.Error);
}
}