679 lines
21 KiB
Plaintext
679 lines
21 KiB
Plaintext
@page "/user/browse"
|
|
@page "/user/browse/{DatabaseStr}/{CollectionStr}"
|
|
@page "/user/browse/{DatabaseStr}/{DatabaseInstanceStr}/{CollectionStr}"
|
|
@using Rms.Risk.Mango.Language
|
|
@using Rms.Risk.Mango.Pivot.Core.MongoDb
|
|
@implements IDisposable
|
|
|
|
@attribute [Authorize]
|
|
|
|
@inject NavigationManager NavigationManager
|
|
@inject IUserSession UserSession
|
|
@inject IJSRuntime JsRuntime
|
|
@inject IAuthorizationService Auth
|
|
|
|
@*
|
|
* dbMango
|
|
*
|
|
* Copyright 2025 Deutsche Bank AG
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*@
|
|
|
|
<style>
|
|
|
|
.panel{
|
|
height: calc(100vh - 150px);
|
|
}
|
|
|
|
.panel .form-control {
|
|
height: 100%;
|
|
}
|
|
|
|
.panel .list-body {
|
|
height: calc(100vh - 150px - 34px);
|
|
max-height: calc(100vh - 150px - 34px);
|
|
overflow-y: auto;
|
|
}
|
|
|
|
.res-field {
|
|
width: calc(100% - 10px);
|
|
height: calc(100vh - 212px);
|
|
overflow: auto;
|
|
margin-left: 5px;
|
|
background-color: #1d2a3b;
|
|
}
|
|
|
|
.meta {
|
|
color: grey;
|
|
}
|
|
|
|
pre {
|
|
width: 100%;
|
|
height: 100%;
|
|
font-size: 10pt;
|
|
background-color: #1d2a3b;
|
|
color: #FFFFFF;
|
|
}
|
|
</style>
|
|
|
|
<h3 class="mt-3">Browse: @SelectedCollection</h3>
|
|
|
|
<AuthorizedOnly Policy="ReadAccess" Resource="@UserSession.Database">
|
|
|
|
<EditForm EditContext="EditContext">
|
|
|
|
<div class="form-row">
|
|
<FormItemText Enabled="@IsReady" Class="mr-2" Name="Timeout (sec)" @bind-Value="Timeout" InputType="number" Icon="icon-clock-sm"/>
|
|
<FormItemText Enabled="@IsReady" Class="mr-2" Name="Max fetch size" @bind-Value="FetchSize" InputType="number" Icon="icon-download-selected-sm" />
|
|
<FormItemSelect Enabled="@IsReady" Class="mr-2" Name="Rows" @bind-Value="Rows" Values="@_rowValues" Icon="icon-number-outline" />
|
|
<FormItemCheckBox Enabled="@IsReady" Class="mr-2" Name="Show as Json" @bind-Value="ShowAsJson" Icon="icon-tos-sm" />
|
|
<div class="flex-stack-vertical">
|
|
<div class="flex-stack-horizontal">
|
|
<div class="form-group">
|
|
<FormButton Enabled="@IsReady" Name="Find" Icon="icon-search-sm" OnClick="Run" IsPrimary="true" />
|
|
</div>
|
|
</div>
|
|
<div>See <a href="/doc/afh?tab=Expressions" target="_blank">documentation</a>...</div>
|
|
</div>
|
|
</div>
|
|
|
|
</EditForm>
|
|
|
|
<SplitPanel Orientation="horizontal" InitialSplit="0.2">
|
|
<First>
|
|
<div class="panel">
|
|
<FormItemList Enabled="@IsReady" Class="mr-2" Name="Collection" @bind-Value="SelectedCollection" Values="@Collections" IsSelectable="IsSelectable">
|
|
<OptionTemplate>
|
|
<div class="d-flex">
|
|
<div class="flex-grow-1 m-1 @GetCollectionClass(context)">@context</div>
|
|
@if (Stats.TryGetValue(context, out var stat))
|
|
{
|
|
if (stat.Sharded)
|
|
{
|
|
<div class="m-1">Sharded</div>
|
|
}
|
|
<div class="m-1 ">@NumbersUtils.ToHumanReadable(stat.Size)</div>
|
|
}
|
|
</div>
|
|
</OptionTemplate>
|
|
</FormItemList>
|
|
</div>
|
|
</First>
|
|
<Second>
|
|
<div class="panel ml-2">
|
|
@* <FormItemText @bind-Value="Text" Name="Filter (AFH syntax)" Class="w-100" /> *@
|
|
<FormTextAutocomplete IsMultiline="true" @bind-Value="Text" Name="Filter (AFH syntax)" Class="w-100" Values="@History" @bind-ShowDropdown="@ShowDropdown" />
|
|
|
|
@if ( !IsReady )
|
|
{
|
|
<ProgressSpinner/>
|
|
}
|
|
else if (ShowAsJson)
|
|
{
|
|
<FormJson Class="res-field row" Value="@Result"/>
|
|
}
|
|
else
|
|
{
|
|
<SimplePivotComponent PivotName="find"
|
|
Class="overflow-auto"
|
|
Rows="@Rows"
|
|
CollectionName="find"
|
|
PivotData="@ResultPivot"
|
|
HandleCellClick="@OnCellClick"
|
|
/>
|
|
}
|
|
</div>
|
|
</Second>
|
|
</SplitPanel>
|
|
|
|
|
|
</AuthorizedOnly>
|
|
|
|
@code {
|
|
[CascadingParameter] public IModalService Modal { get; set; } = null!;
|
|
|
|
[Parameter] public string? DatabaseStr { get; set; }
|
|
[Parameter] public string? DatabaseInstanceStr { get; set; }
|
|
[Parameter] public string? CollectionStr { get; set; }
|
|
|
|
|
|
|
|
[Parameter]
|
|
[SupplyParameterFromQuery(Name = "q")]
|
|
public string Text { get; set; } = "";
|
|
|
|
private List<string> Collections { get; set; } = [];
|
|
private ConcurrentDictionary<string, CollectionStats> Stats { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
|
private static readonly List<int> _rowValues = Enumerable.Range(0, 8).Select(x => x * 5 + 25).ToList();
|
|
private Dictionary<string, List<string>> AllHistory { get; set; } = [];
|
|
|
|
private int Rows
|
|
{
|
|
get;
|
|
set
|
|
{
|
|
if (field == value)
|
|
return;
|
|
field = value;
|
|
InvokeAsync(StateHasChanged);
|
|
}
|
|
} = 35;
|
|
|
|
private List<string> History
|
|
{
|
|
get
|
|
{
|
|
var key = $"{Database}|{DatabaseInstance}|{SelectedCollection}";
|
|
if ( AllHistory.TryGetValue(key, out var hist) )
|
|
{
|
|
hist.Sort(StringComparer.OrdinalIgnoreCase);
|
|
return hist;
|
|
}
|
|
hist = [];
|
|
AllHistory[key] = hist;
|
|
return hist;
|
|
}
|
|
}
|
|
|
|
private string SelectedCollection
|
|
{
|
|
get => UserSession.Collection;
|
|
set
|
|
{
|
|
if (UserSession.Collection == value)
|
|
return;
|
|
UserSession.Collection = value;
|
|
ShowDropdown = false;
|
|
Text = "";
|
|
SyncUrl();
|
|
InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
|
|
private string Database
|
|
{
|
|
get => UserSession.Database;
|
|
set
|
|
{
|
|
if (UserSession.Database == value)
|
|
return;
|
|
UserSession.Database = value;
|
|
SyncUrl();
|
|
InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
|
|
private string DatabaseInstance
|
|
{
|
|
get => UserSession.DatabaseInstance;
|
|
set
|
|
{
|
|
if (UserSession.DatabaseInstance == value)
|
|
return;
|
|
UserSession.DatabaseInstance = value;
|
|
SyncUrl();
|
|
}
|
|
}
|
|
|
|
private string Timeout { get; set; } = "20";
|
|
private string FetchSize { get; set; } = "100";
|
|
private bool IsReady { get; set; }
|
|
private bool ShowAsJson { get; set; }
|
|
private bool ShowDropdown { get; set; }
|
|
|
|
private string Result { get; set; } = "{}";
|
|
private List<BsonDocument> ResultBson { get; set; } = [];
|
|
public ArrayBasedPivotData ResultPivot { get; set; } = new([]);
|
|
|
|
private EditContext? _editContext;
|
|
private EditContext EditContext => _editContext!;
|
|
|
|
private readonly CancellationTokenSource _globalCancellation = new();
|
|
|
|
private static string GetCollectionClass(string collectionName) =>
|
|
collectionName.EndsWith("-Meta", StringComparison.OrdinalIgnoreCase)
|
|
? "meta"
|
|
: "";
|
|
|
|
protected override void OnInitialized()
|
|
{
|
|
_editContext = new (this);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_globalCancellation.Cancel();
|
|
_globalCancellation.Dispose();
|
|
}
|
|
|
|
|
|
|
|
private class BrowseState
|
|
{
|
|
public string Text { get; set; } = "";
|
|
public int Rows { get; set; } = 25;
|
|
public Dictionary<string, List<string>> History { get; set; } = [];
|
|
public string? Collection { get; set; }
|
|
}
|
|
|
|
protected override async Task OnAfterRenderAsync(bool firstRender)
|
|
{
|
|
if (!firstRender)
|
|
return;
|
|
|
|
if (string.IsNullOrWhiteSpace(DatabaseStr))
|
|
DatabaseStr = Database;
|
|
else
|
|
Database = DatabaseStr;
|
|
|
|
if (string.IsNullOrWhiteSpace(DatabaseInstanceStr))
|
|
DatabaseInstanceStr = DatabaseInstance;
|
|
else
|
|
DatabaseInstance = DatabaseInstanceStr;
|
|
|
|
var cts = CancellationTokenSource.CreateLinkedTokenSource(_globalCancellation.Token, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
|
|
var state = await GetState(cts.Token);
|
|
|
|
if ( state != null )
|
|
{
|
|
if ( state.History.Any() )
|
|
AllHistory = state.History;
|
|
Rows = state.Rows;
|
|
if ( string.IsNullOrWhiteSpace(Text) && !string.IsNullOrWhiteSpace(state.Text))
|
|
Text = state.Text;
|
|
if (string.IsNullOrWhiteSpace(CollectionStr) && !string.IsNullOrWhiteSpace(state.Collection))
|
|
CollectionStr = state.Collection;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(CollectionStr))
|
|
CollectionStr = SelectedCollection;
|
|
else
|
|
SelectedCollection = CollectionStr;
|
|
SyncUrl();
|
|
|
|
|
|
if (Text is "null" or null)
|
|
Text = "";
|
|
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
var admin = UserSession.MongoDbAdmin;
|
|
|
|
var cts2 = CancellationTokenSource.CreateLinkedTokenSource(_globalCancellation.Token, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
|
|
var grouped = (await admin.ListCollections(cts2.Token))
|
|
.GroupBy(x =>
|
|
x.EndsWith("-Meta", StringComparison.OrdinalIgnoreCase)
|
|
? " Meta"
|
|
: x.EndsWith("-Cache", StringComparison.OrdinalIgnoreCase)
|
|
? " Cache"
|
|
: " Data"
|
|
);
|
|
|
|
Collections.Clear();
|
|
foreach( var group in grouped)
|
|
{
|
|
Collections.Add(group.Key);
|
|
Collections.AddRange(group.OrderBy(x => x).Select(x => x));
|
|
}
|
|
|
|
if (!Collections.Contains(SelectedCollection))
|
|
SelectedCollection = Collections.FirstOrDefault( x => !x.StartsWith(" ")) ?? "";
|
|
|
|
IsReady = true;
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
_ = Task.Run(LoadCollStats, _globalCancellation.Token);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Display(e);
|
|
}
|
|
}, _globalCancellation.Token);
|
|
}
|
|
|
|
private async Task LoadCollStats()
|
|
{
|
|
var admin = UserSession.MongoDbAdmin;
|
|
var collections = Collections.ToList(); // make a copy to avoid modifying the original list during iteration
|
|
|
|
foreach (var name in collections)
|
|
{
|
|
try
|
|
{
|
|
var cts = CancellationTokenSource.CreateLinkedTokenSource(_globalCancellation.Token, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
|
|
|
|
var doc = await admin.CollStats(name, cts.Token);
|
|
doc.Details = null; // Remove details to avoid large output
|
|
|
|
Stats[name] = doc;
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task<BrowseState?> GetState(CancellationToken token)
|
|
{
|
|
try
|
|
{
|
|
var json = await JsRuntime.LoadFromLocalStorage("Browse", token);
|
|
|
|
if (string.IsNullOrWhiteSpace(json))
|
|
return null;
|
|
|
|
return JsonUtils.FromJson<BrowseState>(json);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
enum ActionType
|
|
{
|
|
Find
|
|
}
|
|
|
|
private async Task Run(ActionType actionType)
|
|
{
|
|
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(int.Parse(Timeout)));
|
|
|
|
try
|
|
{
|
|
IsReady = false;
|
|
ShowDropdown = false;
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
await SaveState(cts.Token);
|
|
|
|
if (int.TryParse(FetchSize, out var limit) == false)
|
|
limit = 0;
|
|
|
|
var json = "";
|
|
if (!string.IsNullOrWhiteSpace(Text))
|
|
{
|
|
var afh = $$"""FROM "{{SelectedCollection}}" PIPELINE { WHERE {{Text}} }""";
|
|
try
|
|
{
|
|
var ast = LanguageParser.ParseScriptToAST(afh);
|
|
json = ast.AsJson()!.ToJsonString(new() { WriteIndented = true });
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Display(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
var res = actionType switch
|
|
{
|
|
ActionType.Find => await RunFind(json, limit, cts.Token),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(actionType), actionType, null)
|
|
};
|
|
|
|
ResultPivot = res.Item1;
|
|
ResultBson = res.Item2;
|
|
|
|
if (!History.Contains(Text))
|
|
{
|
|
History.Insert(0, Text);
|
|
await SaveState(cts.Token);
|
|
}
|
|
|
|
SyncUrl();
|
|
|
|
await Display(ResultBson);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Display(e);
|
|
}
|
|
finally
|
|
{
|
|
IsReady = true;
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
|
|
private async Task SaveState(CancellationToken token)
|
|
{
|
|
try
|
|
{
|
|
foreach( var key in AllHistory.Keys.ToList())
|
|
{
|
|
var hist = AllHistory[key];
|
|
AllHistory[key] = hist.Distinct(StringComparer.OrdinalIgnoreCase).Take(100).ToList();
|
|
}
|
|
|
|
var state = new BrowseState
|
|
{
|
|
Text = Text,
|
|
Collection = SelectedCollection,
|
|
Rows = Rows,
|
|
History = AllHistory
|
|
};
|
|
|
|
var json = JsonUtils.ToJson(state);
|
|
await JsRuntime.SaveToLocalStorage("Browse", json, token);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// Ignore errors during saving state
|
|
// This is not critical, and we can continue without saving
|
|
}
|
|
}
|
|
private Task Run() => Run(ActionType.Find);
|
|
|
|
private Task Display(Exception e)
|
|
{
|
|
ShowAsJson = true;
|
|
Result = e.ToString();
|
|
return InvokeAsync(StateHasChanged);
|
|
}
|
|
|
|
private Task Display(IEnumerable<BsonDocument> res)
|
|
{
|
|
Result = res.ToJson(new() { Indent = true });
|
|
return InvokeAsync(StateHasChanged);
|
|
}
|
|
|
|
private async Task<(ArrayBasedPivotData, List<BsonDocument>)> RunFind(string text, int limit, CancellationToken token)
|
|
{
|
|
var service = UserSession.MongoDb;
|
|
var results =
|
|
string.IsNullOrWhiteSpace(text) || text.Trim() == "{}"
|
|
? service.FindAsync("{}", limit: limit <= 0 ? -1 : limit, token: token)
|
|
: service.AggregateAsyncRaw(text, limit <= 0 ? -1 : limit, token: token);
|
|
|
|
|
|
var fieldMap = new ConcurrentDictionary<string, FieldMapping>
|
|
{
|
|
["find"] = new(false)
|
|
};
|
|
|
|
var (pd, list) = await MongoDbDataSource.FetchPivotData(
|
|
"find",
|
|
"find",
|
|
fieldMap,
|
|
results,
|
|
null,
|
|
true,
|
|
int.Parse(FetchSize),
|
|
true,
|
|
token);
|
|
|
|
if (list.Count == 0)
|
|
list.Add(BsonDocument.Parse(@$"{{""Result"": ""No data fetched from {SelectedCollection}""}}"));
|
|
|
|
return (pd, list);
|
|
}
|
|
|
|
private void SyncUrl()
|
|
{
|
|
var url = NavigationManager.BaseUri + $"user/browse/{Database}";
|
|
if (!string.IsNullOrWhiteSpace(DatabaseInstance))
|
|
url += $"/{DatabaseInstance}";
|
|
url += $"/{SelectedCollection}";
|
|
if (!string.IsNullOrWhiteSpace(Text))
|
|
url += $"?q={Uri.EscapeDataString(Text)}";
|
|
JsRuntime.InvokeAsync<string>("DashboardUtils.ChangeUrl", url);
|
|
}
|
|
|
|
private async Task<bool> OnCellClick(DynamicObject row, string columnName)
|
|
{
|
|
try
|
|
{
|
|
var id = TableControl.GetDynamicMember(row, "_id");
|
|
if (id == null)
|
|
return true;
|
|
|
|
var bson = ResultBson.FirstOrDefault(x => x["_id"].ToString() == id.ToString());
|
|
if (bson == null)
|
|
return true;
|
|
|
|
var oldId = bson["_id"];
|
|
|
|
var enableWrite = await Auth.AuthorizeAsync(
|
|
UserSession.User.GetUser(),
|
|
UserSession.Database,
|
|
[new WriteAccessRequirement()]);
|
|
|
|
var res = await Find.ShowBsonDialog(Modal, id.ToString()!, bson, enableWrite.Succeeded);
|
|
if (res == null)
|
|
return true;
|
|
|
|
if (enableWrite.Succeeded)
|
|
{
|
|
if (res.Value.ShouldUpdate)
|
|
{
|
|
bson = BsonDocument.Parse(res.Value.Json);
|
|
await OnUpdate(oldId, bson);
|
|
}
|
|
else
|
|
await OnDelete(oldId);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await ModalDialogUtils.ShowExceptionDialog(Modal, "Error", e);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private async Task OnDelete(BsonValue id)
|
|
{
|
|
var ticket = await Shell.CanExecuteCommand(UserSession, InvokeAsync, Modal);
|
|
if (string.IsNullOrWhiteSpace(ticket))
|
|
return;
|
|
|
|
var r = await ModalDialogUtils.ShowConfirmationDialog(Modal, $"Delete {id}", "Are you sure to delete document?");
|
|
if (r.Cancelled)
|
|
return;
|
|
|
|
var command = BsonDocument.Parse($@"{{
|
|
""delete"": ""{SelectedCollection}"",
|
|
""deletes"": [{{
|
|
""q"": {{ }},
|
|
""limit"": 1
|
|
}}]
|
|
}}");
|
|
|
|
var idDoc = new BsonDocument
|
|
{
|
|
["_id"] = id
|
|
};
|
|
|
|
command["deletes"][0]["q"] = idDoc;
|
|
|
|
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(int.Parse(Timeout)));
|
|
Shell.UpdateComment(command, ticket, UserSession.User.GetEmail());
|
|
|
|
var res = await UserSession.MongoDbAdmin.RunCommand(command, cts.Token);
|
|
var deleted = res["n"].ToInt32();
|
|
if (deleted != 1)
|
|
{
|
|
Result =
|
|
res.ToJson(new() { Indent = true }) +
|
|
"\n------------------------------------------------------------------\n"+
|
|
command.ToJson(new() { Indent = true });
|
|
ShowAsJson = true;
|
|
await ModalDialogUtils.ShowInfoDialog(Modal, $"Delete {id}", "Failure");
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
else
|
|
await ModalDialogUtils.ShowInfoDialog(Modal, $"Delete {id}", "Success");
|
|
}
|
|
|
|
private async Task OnUpdate(BsonValue id, BsonDocument newBson)
|
|
{
|
|
var ticket = await Shell.CanExecuteCommand(UserSession, InvokeAsync, Modal);
|
|
if (string.IsNullOrWhiteSpace(ticket))
|
|
return;
|
|
|
|
var r = await ModalDialogUtils.ShowConfirmationDialog(Modal, $"Update {id}", "Are you sure to update document?");
|
|
if (r.Cancelled)
|
|
return;
|
|
|
|
var command = BsonDocument.Parse($@"{{
|
|
update: ""{SelectedCollection}"",
|
|
updates: [
|
|
{{
|
|
q: {{ }},
|
|
u: {{ }},
|
|
upsert: false,
|
|
multi: false,
|
|
}}
|
|
],
|
|
ordered: false,
|
|
bypassDocumentValidation: false
|
|
}}");
|
|
|
|
var idDoc = new BsonDocument
|
|
{
|
|
["_id"] = id
|
|
};
|
|
|
|
command["updates"][0]["q"] = idDoc;
|
|
command["updates"][0]["u"] = newBson;
|
|
|
|
Shell.UpdateComment(command, ticket, UserSession.User.GetEmail());
|
|
|
|
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(int.Parse(Timeout)));
|
|
var res = await UserSession.MongoDbAdmin.RunCommand(command, cts.Token);
|
|
|
|
var modified = res["nModified"].ToInt32();
|
|
if (modified != 1)
|
|
{
|
|
Result =
|
|
res.ToJson(new() { Indent = true }) +
|
|
"\n------------------------------------------------------------------\n"+
|
|
command.ToJson(new() { Indent = true });
|
|
ShowAsJson = true;
|
|
await ModalDialogUtils.ShowInfoDialog(Modal, $"Update {id}", "Failure");
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
else
|
|
await ModalDialogUtils.ShowInfoDialog(Modal, $"Update {id}", "Success");
|
|
}
|
|
|
|
private bool IsSelectable(string arg) => !arg.StartsWith(" ");
|
|
|
|
}
|