Adam
/
TourIAm
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

TiamGrid, SignalRDataSource fixes, improvement;

This commit is contained in:
Loretta 2024-06-10 19:29:25 +02:00
parent 96ccf6d86f
commit c349c3c432
2 changed files with 284 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
TIAMSharedUI/Shared/Components/Grids/TiamGrid.cs
View File

@ -1,46 +1,19 @@
using System.ComponentModel; using System.ComponentModel;
using System.Data.Common;
using AyCode.Core; using AyCode.Core;
using AyCode.Core.Enums; using AyCode.Core.Enums;
using AyCode.Core.Extensions; using AyCode.Core.Extensions;
using AyCode.Core.Helpers; using AyCode.Core.Helpers;
using AyCode.Core.Interfaces; using AyCode.Core.Interfaces;
using AyCode.Interfaces.Entities;
using AyCode.Services.SignalRs; using AyCode.Services.SignalRs;
using AyCode.Utils.Extensions; using AyCode.Utils.Extensions;
using DevExpress.Blazor; using DevExpress.Blazor;
using DevExpress.Blazor.Internal;
using Microsoft.AspNetCore.Components; using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using TIAM.Services; using TIAM.Services;
using TIAMWebApp.Shared.Application.Services; using TIAMWebApp.Shared.Application.Services;
using TIAMWebApp.Shared.Application.Utility; using TIAMWebApp.Shared.Application.Utility;
namespace TIAMSharedUI.Shared.Components.Grids namespace TIAMSharedUI.Shared.Components.Grids
{ {
public class GridDataItemChangingEventArgs<TDataItem> : GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
{
internal GridDataItemChangingEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState) : base(grid, dataItem, trackingState)
{
}
public bool IsCanceled { get; set; }
}
public class GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
{
internal GridDataItemChangedEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState)
{
Grid = grid;
DataItem = dataItem;
TrackingState = trackingState;
}
public TiamGrid<TDataItem> Grid { get; }
public TDataItem DataItem { get; }
public TrackingState TrackingState { get; }
}
public class TiamGrid<TDataItem> : DxGrid where TDataItem : class, IId<Guid> public class TiamGrid<TDataItem> : DxGrid where TDataItem : class, IId<Guid>
{ {
protected bool IsFirstInitializeParameters; protected bool IsFirstInitializeParameters;
@ -71,10 +44,12 @@ namespace TIAMSharedUI.Shared.Components.Grids
[Parameter] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; } [Parameter] public EventCallback<IList<TDataItem>> OnDataSourceChanged { get; set; }
[Parameter] public EventCallback<GridDataItemChangingEventArgs<TDataItem>> OnGridItemChanging { get; set; } [Parameter] public EventCallback<GridDataItemChangingEventArgs<TDataItem>> OnGridItemChanging { get; set; }
/// <summary> /// <summary>
/// After server response! /// After the server has responded!
/// </summary> /// </summary>
[Parameter] public EventCallback<GridDataItemChangedEventArgs<TDataItem>> OnGridItemChanged { get; set; } [Parameter]
public EventCallback<GridDataItemChangedEventArgs<TDataItem>> OnGridItemChanged { get; set; }
[Parameter] [Parameter]
[DefaultValue(null)] [DefaultValue(null)]
@ -91,27 +66,7 @@ namespace TIAMSharedUI.Shared.Components.Grids
return _dataSource!; return _dataSource!;
} }
set set => _dataSourceParam = value;
{
if (value == null) return;
_dataSourceParam = value;
//bool equals;
//if ((equals = Equals(_dataSource, value)) == false)
//{
// if (value is SignalRDataSource<TDataItem> dataSource)
// _dataSource = dataSource;
// else
// {
// var crudTags = new SignalRCrudTags(GetAllMessageTag, SignalRTags.None, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
// _dataSource = new SignalRDataSource<TDataItem>(value, SignalRClient, crudTags, ContextId);
// }
//}
//Data = _dataSource;
//if (!equals) OnDataSourceChanged.InvokeAsync(_dataSource);
}
} }
protected override async Task OnInitializedAsync() protected override async Task OnInitializedAsync()
@ -127,7 +82,7 @@ namespace TIAMSharedUI.Shared.Components.Grids
var crudTags = new SignalRCrudTags(GetAllMessageTag, SignalRTags.None, AddMessageTag, UpdateMessageTag, RemoveMessageTag); var crudTags = new SignalRCrudTags(GetAllMessageTag, SignalRTags.None, AddMessageTag, UpdateMessageTag, RemoveMessageTag);
_dataSource = new SignalRDataSource<TDataItem>(SignalRClient, crudTags, ContextId); _dataSource = new SignalRDataSource<TDataItem>(SignalRClient, crudTags, ContextId);
Data = _dataSource; Data = _dataSource;
_dataSource.OnDataSourceLoaded += OnDataSourceLoaded; _dataSource.OnDataSourceLoaded += OnDataSourceLoaded;
@ -136,20 +91,22 @@ namespace TIAMSharedUI.Shared.Components.Grids
await base.OnInitializedAsync(); await base.OnInitializedAsync();
} }
private Task OnDataSourceItemChanged(ItemChangedEventArgs<TDataItem> args) private async Task OnDataSourceItemChanged(ItemChangedEventArgs<TDataItem> args)
{ {
if (args.TrackingState is TrackingState.GetAll or TrackingState.None) return Task.CompletedTask; if (args.TrackingState is TrackingState.GetAll or TrackingState.None) return;
Logger.Info($"{_gridLogName} OnItemLoaded; trackingState: {args.TrackingState}"); Logger.Debug($"{_gridLogName} OnDataSourceItemChanged; trackingState: {args.TrackingState}");
var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, args.Item, args.TrackingState); var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, args.Item, args.TrackingState);
return OnGridItemChanged.InvokeAsync(changedEventArgs); await OnGridItemChanged.InvokeAsync(changedEventArgs);
await InvokeAsync(StateHasChanged);
} }
private Task OnDataSourceLoaded() private Task OnDataSourceLoaded()
{ {
Logger.Info($"{_gridLogName} OnDataSourceLoaded"); Logger.Debug($"{_gridLogName} OnDataSourceLoaded");
Reload(); Reload();
return OnDataSourceChanged.InvokeAsync(_dataSource); return OnDataSourceChanged.InvokeAsync(_dataSource);
} }
@ -165,28 +122,18 @@ namespace TIAMSharedUI.Shared.Components.Grids
} }
} }
public Task AddDataItem(TDataItem dataItem) => AddDataItem(dataItem, AddMessageTag); public Task AddDataItem(TDataItem dataItem)
public Task AddDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Add);
public Task UpdateDataItem(TDataItem dataItem) => UpdateDataItem(dataItem, UpdateMessageTag);
public Task UpdateDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Update);
public Task RemoveDataItem(TDataItem dataItem) => RemoveDataItem(dataItem, RemoveMessageTag);
public Task RemoveDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Remove);
public Task RemoveDataItem(Guid id) => RemoveDataItem(id, RemoveMessageTag);
public async Task RemoveDataItem(Guid id, int messageTag)
{ {
var dataItem = _dataSource.FirstOrDefault(x => x.Id == id); if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();
if (dataItem != null) return _dataSource.Add(dataItem, true);
{ }
_dataSource.Remove(dataItem);
await _dataSource.SaveChanges();
//await RemoveDataItem(dataItem);
}
await InvokeAsync(StateHasChanged); public Task AddDataItemAsync(TDataItem dataItem)
{
if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();
_dataSource.Add(dataItem);
return SaveChangesToServerAsync();
} }
private async Task OnItemSaving(GridEditModelSavingEventArgs e) private async Task OnItemSaving(GridEditModelSavingEventArgs e)
@ -196,7 +143,7 @@ namespace TIAMSharedUI.Shared.Components.Grids
if (e.IsNew && dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid(); if (e.IsNew && dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();
var logText = e.IsNew ? "add" : "update"; var logText = e.IsNew ? "add" : "update";
Logger.Info($"{_gridLogName} OnItemSaving {logText}; Id: {dataItem.Id}"); Logger.Debug($"{_gridLogName} OnItemSaving {logText}; Id: {dataItem.Id}");
await OnGridEditModelSaving.InvokeAsync(e); await OnGridEditModelSaving.InvokeAsync(e);
@ -206,29 +153,46 @@ namespace TIAMSharedUI.Shared.Components.Grids
return; return;
} }
if (!e.IsNew) _dataSource.SetTrackingStateToUpdate(dataItem); if (e.IsNew) await AddDataItemAsync(dataItem);
else else await UpdateDataItemAsync(dataItem);
}
private Task SaveChangesToServerAsync()
{
try
{ {
if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid(); return _dataSource.SaveChangesAsync();
_dataSource.Add(dataItem);
} }
catch (Exception ex)
{
Logger.Error($"{_gridLogName} SaveChangesToServerAsync->SaveChangesAsync error!", ex);
}
return Task.CompletedTask;
}
private async Task<bool> SaveChangesToServer()
{
var result = false;
try try
{ {
var unsavedItems = await _dataSource.SaveChanges(); var unsavedItems = await _dataSource.SaveChanges();
if (unsavedItems.Count > 0) if ((result = unsavedItems.Count == 0) == false)
Logger.Error($"OnItemSaving->TrySaveChanges error! unsavedCount: {unsavedItems.Count}"); Logger.Error($"{_gridLogName} SaveChangesToServer->SaveChanges error! unsavedCount: {unsavedItems.Count}");
} }
catch (Exception ex) catch (Exception ex)
{ {
Logger.Error($"{_gridLogName} OnItemSaving", ex); Logger.Error($"{_gridLogName} OnItemSaving", ex);
} }
return result;
} }
private async Task OnItemDeleting(GridDataItemDeletingEventArgs e) private async Task OnItemDeleting(GridDataItemDeletingEventArgs e)
{ {
Logger.Info($"{_gridLogName} OnItemDeleting"); Logger.Debug($"{_gridLogName} OnItemDeleting");
await OnGridItemDeleting.InvokeAsync(e); await OnGridItemDeleting.InvokeAsync(e);
@ -239,54 +203,9 @@ namespace TIAMSharedUI.Shared.Components.Grids
} }
var dataItem = (e.DataItem as TDataItem)!; var dataItem = (e.DataItem as TDataItem)!;
_dataSource.Remove(dataItem); await RemoveDataItem(dataItem);
var unsavedItems = await _dataSource.SaveChanges();
if (unsavedItems.Count > 0)
Logger.Error($"OnItemDeleting->TrySaveChanges error! unsavedCount: {unsavedItems.Count}");
} }
protected virtual async Task PostDataToServerAsync(TDataItem dataItem, int messageTag, TrackingState trackingState)
{
return;
var changingEventArgs = new GridDataItemChangingEventArgs<TDataItem>(this, dataItem, trackingState);
await OnGridItemChanging.InvokeAsync(changingEventArgs);
if (changingEventArgs.IsCanceled)
{
Logger.Debug($"{_gridLogName} OnDataItemChanging canceled");
return;
}
if (messageTag == 0) return;
Logger.Info($"{_gridLogName} PostDataToServerAsync called; transferId " + dataItem.Id);
if (dataItem.Id.IsNullOrEmpty()) dataItem.Id = Guid.NewGuid();
_dataSource.UpdateCollection(dataItem, trackingState == TrackingState.Remove); //egyből látszódik a változás a grid-ben, nem csak a callback lefutásakor! felhasználóbarátabb... - J.
//SignalRClient.PostDataAsync(messageTag, dataItem, async response =>
//{
// if (response.Status != SignalResponseStatus.Success || response.ResponseData == null)
// {
// RefreshDataSourceAsync().Forget();
// return;
// }
// _dataSource.UpdateCollection(response.ResponseData, trackingState == TrackingState.Remove);
// var changedEventArgs = new GridDataItemChangedEventArgs<TDataItem>(this, response.ResponseData, trackingState);
// await OnDataItemChanged.InvokeAsync(changedEventArgs);
// InvokeAsync(StateHasChanged).Forget();
//}).Forget();
//transfer = await devAdminSignalClient.PostDataAsync(SignalRTags.UpdateTransferAsync, transfer);
}
private void OnCustomizeElement(GridCustomizeElementEventArgs e) private void OnCustomizeElement(GridCustomizeElementEventArgs e)
{ {
if (e.ElementType == GridElementType.DetailCell) if (e.ElementType == GridElementType.DetailCell)
@ -341,5 +260,54 @@ namespace TIAMSharedUI.Shared.Components.Grids
_gridLogName = $"[{GridName}]"; _gridLogName = $"[{GridName}]";
} }
//public Task AddDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Add);
public Task UpdateDataItem(TDataItem dataItem) => _dataSource.Update(dataItem, true);
public Task UpdateDataItemAsync(TDataItem dataItem)
{
_dataSource.Update(dataItem, false);
return SaveChangesToServerAsync();
}
//public Task UpdateDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Update);
public Task AddOrUpdateDataItem(TDataItem dataItem) => _dataSource.AddOrUpdate(dataItem, true);
public Task RemoveDataItem(TDataItem dataItem) => _dataSource.Remove(dataItem, true);
//public Task RemoveDataItem(TDataItem dataItem, int messageTag) => PostDataToServerAsync(dataItem, messageTag, TrackingState.Remove);
public Task RemoveDataItem(Guid id) => RemoveDataItem(id, RemoveMessageTag);
public Task RemoveDataItem(Guid id, int messageTag)
{
var dataItem = _dataSource.FirstOrDefault(x => x.Id == id);
if (dataItem == null) return Task.CompletedTask;
return _dataSource.Remove(dataItem, true);
}
}
public class GridDataItemChangingEventArgs<TDataItem> : GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
{
internal GridDataItemChangingEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState) : base(grid, dataItem, trackingState)
{
}
public bool IsCanceled { get; set; }
}
public class GridDataItemChangedEventArgs<TDataItem> where TDataItem : class, IId<Guid>
{
internal GridDataItemChangedEventArgs(TiamGrid<TDataItem> grid, TDataItem dataItem, TrackingState trackingState)
{
Grid = grid;
DataItem = dataItem;
TrackingState = trackingState;
}
public TiamGrid<TDataItem> Grid { get; }
public TDataItem DataItem { get; }
public TrackingState TrackingState { get; }
} }
} }

229
TIAMWebApp/Shared/Utility/SignalRDataSource.cs
View File

@ -131,7 +131,7 @@ namespace TIAMWebApp.Shared.Application.Utility
var resultList = (await SignalRClient.GetAllAsync<List<T>>(SignalRCrudTags.GetAllMessageTag, ContextId)) ?? throw new NullReferenceException(); var resultList = (await SignalRClient.GetAllAsync<List<T>>(SignalRCrudTags.GetAllMessageTag, ContextId)) ?? throw new NullReferenceException();
LoadDataSource(resultList); await LoadDataSource(resultList);
} }
public Task LoadDataSourceAsync(bool clearChangeTracking = true) public Task LoadDataSourceAsync(bool clearChangeTracking = true)
@ -141,9 +141,9 @@ namespace TIAMWebApp.Shared.Application.Utility
return SignalRClient.GetAllAsync<List<T>>(SignalRCrudTags.GetAllMessageTag, ContextId, result=> return SignalRClient.GetAllAsync<List<T>>(SignalRCrudTags.GetAllMessageTag, ContextId, result=>
{ {
if (result.Status != SignalResponseStatus.Success || result.ResponseData == null) if (result.Status != SignalResponseStatus.Success || result.ResponseData == null)
throw new NullReferenceException($"result.Status != SignalResponseStatus.Success || result.ResponseData == null; Status: {SignalResponseStatus.Success}"); throw new NullReferenceException($"LoadDataSourceAsync; result.Status != SignalResponseStatus.Success || result.ResponseData == null; Status: {SignalResponseStatus.Success}");
LoadDataSource(result.ResponseData); LoadDataSource(result.ResponseData).Forget();
}); });
} }
@ -225,7 +225,7 @@ namespace TIAMWebApp.Shared.Application.Utility
Monitor.Enter(_syncRoot); Monitor.Enter(_syncRoot);
try try
{ {
Update(index, value); UpdateUnsafe(index, value);
} }
finally finally
{ {
@ -235,11 +235,6 @@ namespace TIAMWebApp.Shared.Application.Utility
} }
} }
/// <summary>
/// AddMessageTag
/// </summary>
/// <param name="newValue"></param>
/// <exception cref="ArgumentException"></exception>
public void Add(T newValue) public void Add(T newValue)
{ {
if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"Add->newValue.Id.IsNullOrEmpty()"); if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"Add->newValue.Id.IsNullOrEmpty()");
@ -257,15 +252,37 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
}
/// <summary>
/// AddMessageTag
/// </summary>
/// <param name="newValue"></param>
/// <param name="autoSave"></param>
/// <exception cref="ArgumentException"></exception>
public async Task<T> Add(T newValue, bool autoSave)
{
Monitor.Enter(_syncRoot);
try
{
Add(newValue);
return autoSave ? await SaveItem(newValue, TrackingState.Add) : newValue;
}
finally
{
Monitor.Exit(_syncRoot);
}
} }
/// <summary> /// <summary>
/// AddMessageTag or UpdateMessageTag /// AddMessageTag or UpdateMessageTag
/// </summary> /// </summary>
/// <param name="newValue"></param> /// <param name="newValue"></param>
/// <param name="autoSave"></param>
/// <returns></returns> /// <returns></returns>
public T AddOrUpdate(T newValue) public async Task<T> AddOrUpdate(T newValue, bool autoSave)
{ {
if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"AddOrUpdate->newValue.Id.IsNullOrEmpty()"); if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"AddOrUpdate->newValue.Id.IsNullOrEmpty()");
@ -275,7 +292,7 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
var index = IndexOf(newValue); var index = IndexOf(newValue);
return index > -1 ? Update(index, newValue) : UnsafeAdd(newValue); return index > -1 ? await Update(index, newValue, autoSave) : await Add(newValue, autoSave);
} }
finally finally
{ {
@ -292,12 +309,10 @@ namespace TIAMWebApp.Shared.Application.Utility
// } // }
//} //}
protected T UnsafeAdd(T newValue) protected void UnsafeAdd(T newValue)
{ {
TrackingItems.AddTrackingItem(TrackingState.Add, newValue); TrackingItems.AddTrackingItem(TrackingState.Add, newValue);
InnerList.Add(newValue); InnerList.Add(newValue);
return newValue;
} }
/// <summary> /// <summary>
@ -305,6 +320,7 @@ namespace TIAMWebApp.Shared.Application.Utility
/// </summary> /// </summary>
/// <param name="index"></param> /// <param name="index"></param>
/// <param name="newValue"></param> /// <param name="newValue"></param>
/// <param name="autoSave"></param>
/// <exception cref="ArgumentException"></exception> /// <exception cref="ArgumentException"></exception>
/// <exception cref="NullReferenceException"></exception> /// <exception cref="NullReferenceException"></exception>
public void Insert(int index, T newValue) public void Insert(int index, T newValue)
@ -316,7 +332,7 @@ namespace TIAMWebApp.Shared.Application.Utility
try try
{ {
if (Contains(newValue)) if (Contains(newValue))
throw new ArgumentException($@"It already contains this Id! Id: {newValue.Id}", nameof(newValue)); throw new ArgumentException($@"Insert; It already contains this Id! Id: {newValue.Id}", nameof(newValue));
TrackingItems.AddTrackingItem(TrackingState.Add, newValue); TrackingItems.AddTrackingItem(TrackingState.Add, newValue);
InnerList.Insert(index, newValue); InnerList.Insert(index, newValue);
@ -325,28 +341,60 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
} }
public async Task<T> Insert(int index, T newValue, bool autoSave)
{
Monitor.Enter(_syncRoot);
try
{
Insert(index, newValue);
return autoSave ? await SaveItem(newValue, TrackingState.Add) : newValue;
}
finally
{
Monitor.Exit(_syncRoot);
}
}
/// <summary> /// <summary>
/// UpdateMessageTag /// UpdateMessageTag
/// </summary> /// </summary>
/// <param name="newItem"></param> /// <param name="newItem"></param>
public T Update(T newItem) => Update(IndexOf(newItem), newItem); /// <param name="autoSave"></param>
public Task<T> Update(T newItem, bool autoSave) => Update(IndexOf(newItem), newItem, autoSave);
/// <summary> /// <summary>
/// UpdateMessageTag /// UpdateMessageTag
/// </summary> /// </summary>
/// <param name="index"></param> /// <param name="index"></param>
/// <param name="newValue"></param> /// <param name="newValue"></param>
/// <param name="autoSave"></param>
/// /// <exception cref="ArgumentException"></exception> /// /// <exception cref="ArgumentException"></exception>
/// /// <exception cref="NullReferenceException"></exception> /// /// <exception cref="NullReferenceException"></exception>
/// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception>
public T Update(int index, T newValue) public async Task<T> Update(int index, T newValue, bool autoSave)
{
Monitor.Enter(_syncRoot);
try
{
UpdateUnsafe(index, newValue);
return autoSave ? await SaveItem(newValue, TrackingState.Update) : newValue;
}
finally
{
Monitor.Exit(_syncRoot);
}
}
private void UpdateUnsafe(int index, T newValue)
{ {
if (default(T) != null && newValue == null) throw new NullReferenceException(nameof(newValue)); if (default(T) != null && newValue == null) throw new NullReferenceException(nameof(newValue));
if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"Update->newValue.Id.IsNullOrEmpty()"); if (newValue.Id.IsNullOrEmpty()) throw new ArgumentNullException(nameof(newValue), @"UpdateUnsafe->newValue.Id.IsNullOrEmpty()");
if ((uint)index >= (uint)Count) throw new ArgumentOutOfRangeException(nameof(index)); if ((uint)index >= (uint)Count) throw new ArgumentOutOfRangeException(nameof(index));
Monitor.Enter(_syncRoot); Monitor.Enter(_syncRoot);
@ -356,20 +404,18 @@ namespace TIAMWebApp.Shared.Application.Utility
var currentItem = InnerList[index]; var currentItem = InnerList[index];
if (currentItem.Id != newValue.Id) if (currentItem.Id != newValue.Id)
throw new ArgumentException($@"currentItem.Id != item.Id! Id: {newValue.Id}", nameof(newValue)); throw new ArgumentException($@"UpdateUnsafe; currentItem.Id != item.Id! Id: {newValue.Id}", nameof(newValue));
TrackingItems.AddTrackingItem(TrackingState.Update, newValue, currentItem); TrackingItems.AddTrackingItem(TrackingState.Update, newValue, currentItem);
InnerList[index] = newValue; InnerList[index] = newValue;
return newValue;
} }
finally finally
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
} }
/// <summary> /// <summary>
/// RemoveMessageTag /// RemoveMessageTag
/// </summary> /// </summary>
@ -392,9 +438,26 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
} }
public async Task<bool> Remove(T item, bool autoSave)
{
Monitor.Enter(_syncRoot);
try
{
var result = Remove(item);
if (!autoSave || !result) return result;
await SaveItem(item, TrackingState.Remove);
return true;
}
finally
{
Monitor.Exit(_syncRoot);
}
}
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
@ -439,9 +502,27 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
} }
public async Task RemoveAt(int index, bool autoSave)
{
Monitor.Enter(_syncRoot);
try
{
var currentItem = InnerList[index];
RemoveAt(index);
if (autoSave)
{
await SaveItem(currentItem, TrackingState.Remove);
}
}
finally
{
Monitor.Exit(_syncRoot);
}
}
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
@ -518,7 +599,6 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
try try
{ {
//throw new Exception();
await SaveTrackingItemUnsafe(trackingItem); await SaveTrackingItemUnsafe(trackingItem);
} }
catch(Exception ex) catch(Exception ex)
@ -533,26 +613,49 @@ namespace TIAMWebApp.Shared.Application.Utility
{ {
Monitor.Exit(_syncRoot); Monitor.Exit(_syncRoot);
} }
}
public async Task SaveChangesAsync()
{
Monitor.Enter(_syncRoot);
try
{
foreach (var trackingItem in TrackingItems.ToList())
{
try
{
await SaveTrackingItemUnsafeAsync(trackingItem);
}
catch(Exception ex)
{
TryRollbackItem(trackingItem.CurrentValue.Id, out _);
}
}
}
finally
{
Monitor.Exit(_syncRoot);
}
} }
/// <summary> /// <summary>
/// ///
/// </summary> /// </summary>
/// <param name="id"></param> /// <param name="id"></param>
/// <param name="resultItem"></param>
/// <returns></returns> /// <returns></returns>
public async Task<T?> SaveItem(Guid id) public async Task<T> SaveItem(Guid id)
{ {
Monitor.Enter(_syncRoot); Monitor.Enter(_syncRoot);
try try
{ {
T? resultItem = null; T resultItem = null!;
if (TryGetTrackingItem(id, out var trackingItem)) if (TryGetTrackingItem(id, out var trackingItem))
resultItem = await SaveTrackingItemUnsafe(trackingItem); resultItem = await SaveTrackingItemUnsafe(trackingItem);
if (resultItem == null) throw new NullReferenceException($"SaveItem; resultItem == null");
return resultItem; return resultItem;
} }
finally finally
@ -561,17 +664,18 @@ namespace TIAMWebApp.Shared.Application.Utility
} }
} }
public async Task<T?> SaveItem(Guid id, TrackingState trackingState) public async Task<T> SaveItem(Guid id, TrackingState trackingState)
{ {
Monitor.Enter(_syncRoot); Monitor.Enter(_syncRoot);
try try
{ {
T? resultItem = null; T resultItem = null!;
if (TryGetValue(id, out var item)) if (TryGetValue(id, out var item))
resultItem = await SaveItem(item, trackingState); resultItem = await SaveItem(item, trackingState);
if (resultItem == null) throw new NullReferenceException($"SaveItem; resultItem == null");
return resultItem; return resultItem;
} }
finally finally
@ -580,31 +684,68 @@ namespace TIAMWebApp.Shared.Application.Utility
} }
} }
public Task<T?> SaveItem(T item, TrackingState trackingState) => SaveItemUnsafe(item, trackingState); public Task<T> SaveItem(T item, TrackingState trackingState) => SaveItemUnsafe(item, trackingState);
protected Task<T?> SaveTrackingItemUnsafe(TrackingItem<T> trackingItem) protected Task<T> SaveTrackingItemUnsafe(TrackingItem<T> trackingItem)
=> SaveItemUnsafe(trackingItem.CurrentValue, trackingItem.TrackingState); => SaveItemUnsafe(trackingItem.CurrentValue, trackingItem.TrackingState);
protected async Task<T?> SaveItemUnsafe(T item, TrackingState trackingState) protected Task SaveTrackingItemUnsafeAsync(TrackingItem<T> trackingItem)
=> SaveItemUnsafeAsync(trackingItem.CurrentValue, trackingItem.TrackingState);
protected async Task<T> SaveItemUnsafe(T item, TrackingState trackingState)
{ {
var messageTag = SignalRCrudTags.GetMessageTagByTrackingState(trackingState); var messageTag = SignalRCrudTags.GetMessageTagByTrackingState(trackingState);
if (messageTag == SignalRTags.None) return null; //throw new ArgumentException($"messageTag == SignalRTags.None"); if (messageTag == SignalRTags.None) throw new ArgumentException($"SaveItemUnsafe; messageTag == SignalRTags.None");
var result = await SignalRClient.PostDataAsync(messageTag, item); var result = await SignalRClient.PostDataAsync(messageTag, item);
if (result == null) return null; //throw new NullReferenceException($"result == null"); if (result == null) throw new NullReferenceException($"SaveItemUnsafe; result == null");
if (TryGetTrackingItem(item.Id, out var trackingItem)) await ProcessSavedResponseItem(result, trackingState);
TrackingItems.Remove(trackingItem);
if (TryGetIndex(result.Id, out var index))
InnerList[index] = result;
var eventArgs = new ItemChangedEventArgs<T>(result, trackingState);
if (OnDataSourceItemChanged != null) await OnDataSourceItemChanged.Invoke(eventArgs);
return result; return result;
} }
protected Task SaveItemUnsafeAsync(T item, TrackingState trackingState)
{
var messageTag = SignalRCrudTags.GetMessageTagByTrackingState(trackingState);
if (messageTag == SignalRTags.None) return Task.CompletedTask;
return SignalRClient.PostDataAsync(messageTag, item, response =>
{
Monitor.Enter(_syncRoot);
try
{
if (response.Status != SignalResponseStatus.Success || response.ResponseData == null)
{
if (TryRollbackItem(item.Id, out _)) return;
throw new NullReferenceException($"SaveItemUnsafeAsync; result.Status != SignalResponseStatus.Success || result.ResponseData == null; Status: {SignalResponseStatus.Success}");
}
ProcessSavedResponseItem(response.ResponseData, trackingState).Forget();
}
finally
{
Monitor.Exit(_syncRoot);
}
});
}
private async Task ProcessSavedResponseItem(T? resultItem, TrackingState trackingState)
{
if (resultItem == null) return;
if (TryGetTrackingItem(resultItem.Id, out var trackingItem))
TrackingItems.Remove(trackingItem);
if (TryGetIndex(resultItem.Id, out var index))
InnerList[index] = resultItem;
var eventArgs = new ItemChangedEventArgs<T>(resultItem, trackingState);
if (OnDataSourceItemChanged != null) await OnDataSourceItemChanged.Invoke(eventArgs);
}
protected void RollbackItemUnsafe(TrackingItem<T> trackingItem) protected void RollbackItemUnsafe(TrackingItem<T> trackingItem)
{ {
if (TryGetIndex(trackingItem.CurrentValue.Id, out var index)) if (TryGetIndex(trackingItem.CurrentValue.Id, out var index))