sevenhill
482 lines
18 KiB
C#
482 lines
18 KiB
C#
using System.Text;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Options;
|
|
using QMax.Api.Configuration;
|
|
using QMax.Api.Data;
|
|
using QMax.Api.Infrastructure.Max;
|
|
using QMax.Api.Infrastructure.Storage;
|
|
|
|
namespace QMax.Api.Controllers;
|
|
|
|
[ApiController]
|
|
[AllowAnonymous]
|
|
[Route("admin")]
|
|
public sealed class AdminController(
|
|
QMaxDbContext db,
|
|
IOptions<QMaxOptions> options,
|
|
IAttachmentStorageService storage,
|
|
IMaxBridgeClient maxBridge) : ControllerBase
|
|
{
|
|
private readonly QMaxOptions _options = options.Value;
|
|
|
|
[HttpGet]
|
|
public async Task<IActionResult> Index([FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode))
|
|
{
|
|
return Content(AdminShell("<h1>QMAX Admin</h1><p>Open this page with <code>?pairingCode=...</code>.</p>"), "text/html", Encoding.UTF8);
|
|
}
|
|
|
|
var safePairingCode = pairingCode ?? "";
|
|
var status = await BuildStatusAsync(cancellationToken);
|
|
var encodedPairingCode = Uri.EscapeDataString(safePairingCode);
|
|
var latestChats = (await db.Chats.AsNoTracking().ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.LastMessageAt ?? x.UpdatedAt)
|
|
.Take(20)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.Title,
|
|
x.Kind,
|
|
x.UnreadCount,
|
|
LastMessageAt = x.LastMessageAt ?? x.UpdatedAt,
|
|
x.LastMessagePreview
|
|
})
|
|
.ToArray();
|
|
var latestAttachments = (await db.MessageAttachments
|
|
.AsNoTracking()
|
|
.Include(x => x.Message)
|
|
.ThenInclude(x => x!.Chat)
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.CreatedAt)
|
|
.Take(20)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
ChatTitle = x.Message!.Chat!.Title,
|
|
x.OriginalFileName,
|
|
x.Kind,
|
|
x.ContentType,
|
|
x.FileSizeBytes,
|
|
x.CreatedAt
|
|
})
|
|
.ToArray();
|
|
var latestUsers = (await db.Users
|
|
.AsNoTracking()
|
|
.Include(x => x.Sessions)
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.UpdatedAt)
|
|
.Take(20)
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.DisplayName,
|
|
x.PhoneNumber,
|
|
x.CreatedAt,
|
|
x.UpdatedAt,
|
|
Sessions = x.Sessions.Count,
|
|
ActiveSessions = x.Sessions.Count(session => session.RevokedAt == null && session.ExpiresAt > DateTimeOffset.UtcNow)
|
|
})
|
|
.ToArray();
|
|
|
|
var rows = string.Join("", latestChats.Select(chat => $$"""
|
|
<tr>
|
|
<td>{{Html(chat.Title)}}</td>
|
|
<td>{{Html(chat.Kind.ToString())}}</td>
|
|
<td>{{chat.UnreadCount}}</td>
|
|
<td>{{Html(chat.LastMessageAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm"))}}</td>
|
|
<td>{{Html(chat.LastMessagePreview)}}</td>
|
|
</tr>
|
|
"""));
|
|
var attachmentRows = string.Join("", latestAttachments.Select(attachment => $$"""
|
|
<tr>
|
|
<td><a href="/admin/api/attachments/{{attachment.Id}}/content?pairingCode={{encodedPairingCode}}">{{Html(attachment.OriginalFileName)}}</a></td>
|
|
<td>{{Html(attachment.ChatTitle)}}</td>
|
|
<td>{{Html(attachment.Kind.ToString())}}</td>
|
|
<td>{{Html(attachment.ContentType)}}</td>
|
|
<td>{{FormatBytes(attachment.FileSizeBytes)}}</td>
|
|
<td>{{Html(attachment.CreatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm"))}}</td>
|
|
</tr>
|
|
"""));
|
|
var userRows = string.Join("", latestUsers.Select(user => $$"""
|
|
<tr>
|
|
<td>{{Html(user.DisplayName)}}</td>
|
|
<td>{{Html(user.PhoneNumber)}}</td>
|
|
<td>{{user.ActiveSessions}} / {{user.Sessions}}</td>
|
|
<td>{{Html(user.CreatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm"))}}</td>
|
|
<td>{{Html(user.UpdatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm"))}}</td>
|
|
<td><code>{{user.Id}}</code></td>
|
|
</tr>
|
|
"""));
|
|
|
|
var html = $$"""
|
|
<h1>QMAX Admin</h1>
|
|
<nav>
|
|
<a href="/admin?pairingCode={{encodedPairingCode}}">Dashboard</a>
|
|
<a href="/admin/max?pairingCode={{encodedPairingCode}}">MAX Browser</a>
|
|
<a href="/admin/api/status?pairingCode={{encodedPairingCode}}">Status JSON</a>
|
|
<a href="/admin/api/chats?pairingCode={{encodedPairingCode}}">Chats JSON</a>
|
|
<a href="/admin/api/messages?pairingCode={{encodedPairingCode}}">Messages JSON</a>
|
|
<a href="/admin/api/attachments?pairingCode={{encodedPairingCode}}">Attachments JSON</a>
|
|
<a href="/admin/api/users?pairingCode={{encodedPairingCode}}">Users JSON</a>
|
|
</nav>
|
|
<section class="metrics">
|
|
<div><b>{{status.Users}}</b><span>Users</span></div>
|
|
<div><b>{{status.Chats}}</b><span>Chats</span></div>
|
|
<div><b>{{status.Messages}}</b><span>Messages</span></div>
|
|
<div><b>{{status.Attachments}}</b><span>Attachments</span></div>
|
|
<div><b>{{FormatBytes(status.AttachmentBytes)}}</b><span>Media storage</span></div>
|
|
<div><b>{{Html(status.MaxStatus)}}</b><span>MAX</span></div>
|
|
<div><b>{{status.PushDevices}}</b><span>Push devices</span></div>
|
|
</section>
|
|
<section>
|
|
<h2>Latest chats</h2>
|
|
<table>
|
|
<thead><tr><th>Title</th><th>Kind</th><th>Unread</th><th>Updated</th><th>Preview</th></tr></thead>
|
|
<tbody>{{rows}}</tbody>
|
|
</table>
|
|
</section>
|
|
<section>
|
|
<h2>Users</h2>
|
|
<table>
|
|
<thead><tr><th>Name</th><th>Phone</th><th>Sessions</th><th>Created</th><th>Updated</th><th>Id</th></tr></thead>
|
|
<tbody>{{userRows}}</tbody>
|
|
</table>
|
|
</section>
|
|
<section>
|
|
<h2>Latest attachments</h2>
|
|
<table>
|
|
<thead><tr><th>File</th><th>Chat</th><th>Kind</th><th>Content type</th><th>Size</th><th>Created</th></tr></thead>
|
|
<tbody>{{attachmentRows}}</tbody>
|
|
</table>
|
|
</section>
|
|
""";
|
|
|
|
return Content(AdminShell(html), "text/html", Encoding.UTF8);
|
|
}
|
|
|
|
[HttpGet("api/status")]
|
|
public async Task<IActionResult> Status([FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
return Ok(await BuildStatusAsync(cancellationToken));
|
|
}
|
|
|
|
[HttpGet("api/chats")]
|
|
public async Task<IActionResult> Chats([FromQuery] string? pairingCode, [FromQuery] string? q, [FromQuery] int take = 100, CancellationToken cancellationToken = default)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var query = db.Chats.AsNoTracking();
|
|
if (!string.IsNullOrWhiteSpace(q))
|
|
{
|
|
query = query.Where(x => x.Title.Contains(q) || (x.LastMessagePreview != null && x.LastMessagePreview.Contains(q)));
|
|
}
|
|
|
|
var chats = (await query
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.LastMessageAt ?? x.UpdatedAt)
|
|
.Take(Math.Clamp(take, 1, 500))
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.ExternalId,
|
|
x.Kind,
|
|
x.Title,
|
|
x.UnreadCount,
|
|
x.IsPinned,
|
|
x.IsMuted,
|
|
x.IsArchived,
|
|
x.LastMessageAt,
|
|
x.LastMessagePreview,
|
|
x.UpdatedAt
|
|
})
|
|
.ToArray();
|
|
|
|
return Ok(chats);
|
|
}
|
|
|
|
[HttpGet("api/messages")]
|
|
public async Task<IActionResult> Messages([FromQuery] string? pairingCode, [FromQuery] Guid? chatId, [FromQuery] string? q, [FromQuery] int take = 100, CancellationToken cancellationToken = default)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var query = db.Messages.AsNoTracking().Include(x => x.Chat).Include(x => x.Attachments).Where(x => x.DeletedAt == null);
|
|
if (chatId is not null)
|
|
{
|
|
query = query.Where(x => x.ChatId == chatId);
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(q))
|
|
{
|
|
query = query.Where(x => x.Text != null && x.Text.Contains(q));
|
|
}
|
|
|
|
var messages = (await query
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.SentAt)
|
|
.Take(Math.Clamp(take, 1, 500))
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.ChatId,
|
|
ChatTitle = x.Chat!.Title,
|
|
x.Direction,
|
|
x.SenderName,
|
|
x.Text,
|
|
x.SentAt,
|
|
x.DeliveryState,
|
|
x.Error,
|
|
Attachments = x.Attachments.Count
|
|
})
|
|
.ToArray();
|
|
|
|
return Ok(messages);
|
|
}
|
|
|
|
[HttpGet("api/users")]
|
|
public async Task<IActionResult> Users([FromQuery] string? pairingCode, [FromQuery] int take = 100, CancellationToken cancellationToken = default)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var users = (await db.Users
|
|
.AsNoTracking()
|
|
.Include(x => x.Sessions)
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.UpdatedAt)
|
|
.Take(Math.Clamp(take, 1, 500))
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.DisplayName,
|
|
x.PhoneNumber,
|
|
x.AvatarPath,
|
|
x.CreatedAt,
|
|
x.UpdatedAt,
|
|
Sessions = x.Sessions
|
|
.OrderByDescending(session => session.LastSeenAt)
|
|
.Select(session => new
|
|
{
|
|
session.Id,
|
|
session.DeviceName,
|
|
session.CreatedAt,
|
|
session.LastSeenAt,
|
|
session.ExpiresAt,
|
|
IsActive = session.RevokedAt == null && session.ExpiresAt > DateTimeOffset.UtcNow,
|
|
session.RevokedAt
|
|
})
|
|
.ToArray()
|
|
})
|
|
.ToArray();
|
|
|
|
return Ok(users);
|
|
}
|
|
|
|
[HttpGet("api/attachments")]
|
|
public async Task<IActionResult> Attachments([FromQuery] string? pairingCode, [FromQuery] Guid? chatId, [FromQuery] int take = 100, CancellationToken cancellationToken = default)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var query = db.MessageAttachments.AsNoTracking().Include(x => x.Message).ThenInclude(x => x!.Chat).AsQueryable();
|
|
if (chatId is not null)
|
|
{
|
|
query = query.Where(x => x.Message!.ChatId == chatId);
|
|
}
|
|
|
|
var attachments = (await query
|
|
.ToArrayAsync(cancellationToken))
|
|
.OrderByDescending(x => x.CreatedAt)
|
|
.Take(Math.Clamp(take, 1, 500))
|
|
.Select(x => new
|
|
{
|
|
x.Id,
|
|
x.MessageId,
|
|
ChatId = x.Message!.ChatId,
|
|
ChatTitle = x.Message.Chat!.Title,
|
|
FileName = x.OriginalFileName,
|
|
x.ContentType,
|
|
x.FileSizeBytes,
|
|
x.Kind,
|
|
x.RemoteUrl,
|
|
x.CreatedAt,
|
|
ContentPath = $"/admin/api/attachments/{x.Id}/content"
|
|
})
|
|
.ToArray();
|
|
|
|
return Ok(attachments);
|
|
}
|
|
|
|
[HttpGet("api/attachments/{id:guid}/content")]
|
|
public async Task<IActionResult> AttachmentContent(Guid id, [FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var attachment = await db.MessageAttachments.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (attachment is null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var path = storage.GetPath(attachment.StorageFileName);
|
|
return System.IO.File.Exists(path)
|
|
? PhysicalFile(path, attachment.ContentType, attachment.OriginalFileName, enableRangeProcessing: true)
|
|
: NotFound();
|
|
}
|
|
|
|
[HttpDelete("api/attachments/{id:guid}")]
|
|
public async Task<IActionResult> DeleteAttachment(Guid id, [FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var attachment = await db.MessageAttachments.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (attachment is null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var path = storage.GetPath(attachment.StorageFileName);
|
|
db.MessageAttachments.Remove(attachment);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
if (System.IO.File.Exists(path))
|
|
{
|
|
System.IO.File.Delete(path);
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpDelete("api/users/{id:guid}")]
|
|
public async Task<IActionResult> DeleteUser(Guid id, [FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var user = await db.Users.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (user is null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
await db.UserSessions.Where(x => x.UserId == id).ExecuteDeleteAsync(cancellationToken);
|
|
await db.PushDevices.Where(x => x.UserId == id).ExecuteDeleteAsync(cancellationToken);
|
|
db.Users.Remove(user);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpDelete("api/chats/{id:guid}")]
|
|
public async Task<IActionResult> DeleteChat(Guid id, [FromQuery] string? pairingCode, CancellationToken cancellationToken)
|
|
{
|
|
if (!IsPairingCodeValid(pairingCode)) return Unauthorized();
|
|
|
|
var chat = await db.Chats
|
|
.Include(x => x.Messages)
|
|
.ThenInclude(x => x.Attachments)
|
|
.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
|
|
if (chat is null)
|
|
{
|
|
return NotFound();
|
|
}
|
|
|
|
var files = chat.Messages
|
|
.SelectMany(x => x.Attachments)
|
|
.Select(x => storage.GetPath(x.StorageFileName))
|
|
.Where(System.IO.File.Exists)
|
|
.ToArray();
|
|
|
|
db.Chats.Remove(chat);
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
foreach (var file in files)
|
|
{
|
|
System.IO.File.Delete(file);
|
|
}
|
|
|
|
return NoContent();
|
|
}
|
|
|
|
private async Task<AdminStatusDto> BuildStatusAsync(CancellationToken cancellationToken)
|
|
{
|
|
var maxStatus = await maxBridge.GetStatusAsync(cancellationToken);
|
|
return new AdminStatusDto(
|
|
"QMAX Bridge",
|
|
DateTimeOffset.UtcNow,
|
|
await db.Users.CountAsync(cancellationToken),
|
|
await db.Chats.CountAsync(cancellationToken),
|
|
await db.Messages.CountAsync(cancellationToken),
|
|
await db.MessageAttachments.CountAsync(cancellationToken),
|
|
await db.MessageAttachments.Select(x => (long?)x.FileSizeBytes).SumAsync(cancellationToken) ?? 0,
|
|
await db.PushDevices.CountAsync(cancellationToken),
|
|
maxStatus.IsAuthorized,
|
|
maxStatus.Status,
|
|
maxStatus.LastError);
|
|
}
|
|
|
|
private bool IsPairingCodeValid(string? pairingCode)
|
|
{
|
|
return !string.IsNullOrWhiteSpace(_options.PairingCode) &&
|
|
string.Equals(pairingCode, _options.PairingCode, StringComparison.Ordinal);
|
|
}
|
|
|
|
private static string AdminShell(string body)
|
|
{
|
|
return $$"""
|
|
<!doctype html>
|
|
<html lang="ru">
|
|
<head>
|
|
<meta charset="utf-8" />
|
|
<meta name="viewport" content="width=device-width, initial-scale=1" />
|
|
<title>QMAX Admin</title>
|
|
<style>
|
|
body { margin: 0; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f3f7fa; color: #17212b; }
|
|
main { max-width: 1320px; margin: 0 auto; padding: 18px; }
|
|
h1 { margin: 0 0 14px; font-size: 28px; }
|
|
h2 { margin-top: 26px; font-size: 18px; }
|
|
nav { display: flex; flex-wrap: wrap; gap: 10px; margin-bottom: 16px; }
|
|
nav a { color: #2578c4; text-decoration: none; font-weight: 600; }
|
|
.metrics { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; margin: 16px 0; }
|
|
.metrics div { background: white; border: 1px solid #dde7ee; border-radius: 8px; padding: 12px; }
|
|
.metrics b { display: block; font-size: 24px; }
|
|
.metrics span { color: #6c7883; font-size: 13px; }
|
|
table { width: 100%; border-collapse: collapse; background: white; border: 1px solid #dde7ee; border-radius: 8px; overflow: hidden; }
|
|
th, td { padding: 9px 10px; border-bottom: 1px solid #edf2f5; text-align: left; vertical-align: top; }
|
|
th { color: #6c7883; font-size: 12px; text-transform: uppercase; letter-spacing: .02em; }
|
|
tr:last-child td { border-bottom: 0; }
|
|
code { background: #e7eef3; padding: 2px 5px; border-radius: 5px; }
|
|
</style>
|
|
</head>
|
|
<body><main>{{body}}</main></body>
|
|
</html>
|
|
""";
|
|
}
|
|
|
|
private static string Html(string? value)
|
|
{
|
|
return System.Net.WebUtility.HtmlEncode(value ?? "");
|
|
}
|
|
|
|
private static string FormatBytes(long bytes)
|
|
{
|
|
if (bytes < 1024) return $"{bytes} B";
|
|
var kb = bytes / 1024.0;
|
|
if (kb < 1024) return $"{kb:0.0} KB";
|
|
var mb = kb / 1024.0;
|
|
if (mb < 1024) return $"{mb:0.0} MB";
|
|
return $"{mb / 1024.0:0.0} GB";
|
|
}
|
|
|
|
private sealed record AdminStatusDto(
|
|
string Name,
|
|
DateTimeOffset ServerTime,
|
|
int Users,
|
|
int Chats,
|
|
int Messages,
|
|
int Attachments,
|
|
long AttachmentBytes,
|
|
int PushDevices,
|
|
bool MaxAuthorized,
|
|
string MaxStatus,
|
|
string? MaxLastError);
|
|
}
|