530 lines
16 KiB
Plaintext
530 lines
16 KiB
Plaintext
@page "/user/find"
|
|
@page "/user/find/{DatabaseStr}/{CollectionStr}"
|
|
@page "/user/find/{DatabaseStr}/{DatabaseInstanceStr}/{CollectionStr}"
|
|
@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>
|
|
.js-field {
|
|
height: 330px;
|
|
position: relative;
|
|
}
|
|
|
|
.res-field {
|
|
width: 100%;
|
|
height: calc(100vh - (188px + 300px));
|
|
overflow: auto;
|
|
}
|
|
|
|
pre {
|
|
width: 100%;
|
|
height: 100%;
|
|
font-size: 10pt;
|
|
background-color: #1d2a3b;
|
|
color: #FFFFFF;
|
|
}
|
|
</style>
|
|
|
|
<h3 class="mt-3">Find: @SelectedCollection</h3>
|
|
|
|
<AuthorizedOnly Policy="ReadAccess" Resource="@UserSession.Database">
|
|
<EditForm EditContext="EditContext">
|
|
|
|
<div class="form-row">
|
|
<FormItemSelect Enabled="@IsReady" Class="mr-2" Name="Collection" @bind-Value="SelectedCollection" Values="@Collections" Icon="icon-folder-outline-sm"/>
|
|
<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" />
|
|
<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 class="form-group">
|
|
<FormButton Enabled="@IsReady" Name="Count" Icon="icon-funnel-clear-sm" OnClick="Count" IsPrimary="false" />
|
|
</div>
|
|
<div class="form-group">
|
|
<FormButton Enabled="@IsReady" Name="Explain" Icon="icon-layers-sm" OnClick="Explain" IsPrimary="false" />
|
|
</div>
|
|
<div class="form-group">
|
|
<FormButton Enabled="@IsReady" Name="Format" Icon="icon-pencil-sm" OnClick="Format" IsPrimary="false" />
|
|
</div>
|
|
</div>
|
|
<a href="https://www.mongodb.com/docs/manual/reference/command/find/" target="_blank">See documentation...</a>
|
|
</div>
|
|
</div>
|
|
|
|
</EditForm>
|
|
|
|
<div class="js-field mt-3 mb-1">
|
|
<SplitPanel Orientation="horizontal" InitialSplit="0.5">
|
|
<First>
|
|
<div class="col">
|
|
<div class="mb-2">Filter:</div>
|
|
<FormCodeEditor @bind-Text="Text" MediaType="application/x-json" Class="" />
|
|
</div>
|
|
</First>
|
|
<Second>
|
|
<div class="col">
|
|
<div class="mb-2">Projection: (use {} to see everything, _id MUST be present in the result)</div>
|
|
<FormCodeEditor @bind-Text="Project" MediaType="application/x-json" Class="" />
|
|
</div>
|
|
</Second>
|
|
</SplitPanel>
|
|
</div>
|
|
|
|
@if (!IsReady)
|
|
{
|
|
<ProgressSpinner />
|
|
}
|
|
else if (ShowAsJson)
|
|
{
|
|
<FormJson Class="res-field row" Value="@Result"/>
|
|
}
|
|
else
|
|
{
|
|
<SimplePivotComponent PivotName="find"
|
|
CollectionName="find"
|
|
PivotData="@ResultPivot"
|
|
HandleCellClick="@OnCellClick" />
|
|
}
|
|
</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; }
|
|
|
|
private string Text { get; set; } =
|
|
@"{
|
|
""_id"": {
|
|
""$ne"" : """"
|
|
}
|
|
}";
|
|
|
|
private string Project { get; set; } =
|
|
@"{
|
|
|
|
}";
|
|
|
|
private IReadOnlyCollection<string> Collections { get; set; } = [];
|
|
|
|
private string SelectedCollection
|
|
{
|
|
get => UserSession.Collection;
|
|
set
|
|
{
|
|
if (UserSession.Collection == value)
|
|
return;
|
|
UserSession.Collection = value;
|
|
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 string Result { get; set; } = "{}";
|
|
private List<BsonDocument> ResultBson { get; set; } = [];
|
|
public ArrayBasedPivotData ResultPivot { get; set; } = new([]);
|
|
|
|
|
|
|
|
private EditContext? _editContext;
|
|
private EditContext EditContext => _editContext!;
|
|
|
|
protected override void OnInitialized()
|
|
{
|
|
_editContext = new (this);
|
|
}
|
|
|
|
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;
|
|
|
|
if (string.IsNullOrWhiteSpace(CollectionStr))
|
|
CollectionStr = SelectedCollection;
|
|
else
|
|
SelectedCollection = CollectionStr;
|
|
SyncUrl();
|
|
|
|
var text = await JsRuntime.LoadFromLocalStorage("Find");
|
|
if (!string.IsNullOrWhiteSpace(text))
|
|
Text = text;
|
|
|
|
_ = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
var admin = UserSession.MongoDbAdmin;
|
|
|
|
Collections = await admin.ListCollections();
|
|
if (!Collections.Contains(SelectedCollection))
|
|
SelectedCollection = Collections.FirstOrDefault() ?? "";
|
|
|
|
IsReady = true;
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Display(e);
|
|
}
|
|
});
|
|
}
|
|
|
|
enum ActionType
|
|
{
|
|
Find, Count, Explain
|
|
}
|
|
|
|
private async Task Run(ActionType actionType)
|
|
{
|
|
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(int.Parse(Timeout)));
|
|
|
|
try
|
|
{
|
|
IsReady = false;
|
|
await InvokeAsync(StateHasChanged);
|
|
|
|
await JsRuntime.SaveToLocalStorage("Find", Text, cts.Token);
|
|
|
|
if ( int.TryParse(FetchSize, out var limit) == false )
|
|
limit = 0;
|
|
|
|
var res = actionType switch
|
|
{
|
|
ActionType.Find => await RunFind(Text, Project, limit, cts.Token),
|
|
ActionType.Count => await RunCount (Text, cts.Token),
|
|
ActionType.Explain => await RunExplain(Text, cts.Token),
|
|
_ => throw new ArgumentOutOfRangeException(nameof(actionType), actionType, null)
|
|
};
|
|
|
|
ResultPivot = res.Item1;
|
|
ResultBson = res.Item2;
|
|
|
|
await Display(ResultBson);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
await Display(e);
|
|
}
|
|
finally
|
|
{
|
|
IsReady = true;
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
|
|
private Task Run() => Run(ActionType.Find);
|
|
private Task Count() => Run(ActionType.Count);
|
|
private Task Explain() => Run(ActionType.Explain);
|
|
|
|
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>)> RunExplain(string text, CancellationToken token)
|
|
{
|
|
var service = UserSession.MongoDb;
|
|
var command = $@"{{
|
|
""find"" : ""{SelectedCollection}"",
|
|
""filter"" : {text}
|
|
}}";
|
|
var res = await service.ExplainAsync(command, token);
|
|
ShowAsJson = true;
|
|
return (ArrayBasedPivotData.NoData, [res]);
|
|
}
|
|
|
|
private async Task<(ArrayBasedPivotData, List<BsonDocument>)> RunFind(string text, string project , int limit, CancellationToken token)
|
|
{
|
|
var service = UserSession.MongoDb;
|
|
var results = service.FindAsync(text, false, project, limit: limit <= 0 ? null : 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 async Task<(ArrayBasedPivotData, List<BsonDocument>)> RunCount(string text, CancellationToken token)
|
|
{
|
|
var service = UserSession.MongoDb;
|
|
var result = await service.CountAsync(text, token);
|
|
|
|
var pd = new ArrayBasedPivotData(["Count"]);
|
|
pd.Add([result]);
|
|
|
|
return (pd, [BsonDocument.Parse($"{{ Count: {result} }}"), ]);
|
|
}
|
|
|
|
private void SyncUrl()
|
|
{
|
|
var url = NavigationManager.BaseUri + $"user/find/{Database}";
|
|
if (!string.IsNullOrWhiteSpace(DatabaseInstance))
|
|
url += $"/{DatabaseInstance}";
|
|
url += $"/{SelectedCollection}";
|
|
JsRuntime.InvokeAsync<string>("DashboardUtils.ChangeUrl", url);
|
|
}
|
|
|
|
private async Task Format()
|
|
{
|
|
Text = JsonUtils.FormatJson(Text);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
|
|
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 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");
|
|
}
|
|
|
|
|
|
public static async Task<(bool ShouldUpdate, string Json)?> ShowBsonDialog(IModalService service, string header, BsonDocument bson, bool enableWrite)
|
|
{
|
|
var parameters = new ModalParameters
|
|
{
|
|
{ "Text", bson.ToJson(new() { Indent = true }) },
|
|
{ "EnableWrite", enableWrite }
|
|
};
|
|
|
|
var options = new ModalOptions
|
|
{
|
|
HideCloseButton = true,
|
|
DisableBackgroundCancel = true
|
|
};
|
|
|
|
var form = service.Show<MessageBoxJsonComponent>(header, parameters, options);
|
|
var res = await form.Result;
|
|
if (res.Cancelled)
|
|
return null;
|
|
|
|
var v = (MessageBoxJsonComponent.ResultType?)res.Data;
|
|
if (v == null)
|
|
return null;
|
|
|
|
return (v.ShouldUpdate, v.Json);
|
|
}
|
|
|
|
|
|
}
|