Почему ExpandRow не работает после добавления новой строки? [закрыто] ⇐ C#

[Anonymous]

В моем приложении я использую две сетки данных друг в друге, например master-detail. Подробно, я использую встроенное редактирование, например, в Radzen Blazor DataGrid InLine Editing.
Если я нажму Добавить сведения о заказе и введу данные, а затем сохраните их (OnCreateRowDetail). Мне удается оставаться на той же странице, но я хочу сохранить строку развернутой, но она свернута.
Вот упрощенный код:

Код: Выделить всё

@using System.Globalization
@using System.Security.Claims
@using AutoMapper
@using Microsoft.EntityFrameworkCore

@inject AuthenticationStateProvider _authenticationStateProvider
@inject IMapper Mapper
@inject ILogger _logger
@implements IDisposable
































































@code {
IList SelectedOrders { get; set; }
IQueryable _ordersDto;
IQueryable _order;

RadzenDataGrid _grid;
RadzenDataGrid _gridDetail;

OrderDto? _orderToInsert;
OrderDetailDto? _detailToInsert;
OrderDto orders;
Order orderMap;
OrderDetail orderDetailMap;

int? current_page;
int? pageIndex;

protected override void OnAfterRender(bool firstRender)
{
if (firstRender)
{
_grid.SettingsChanged = new EventCallback(this, async (DataGridSettings settings) =>
{
current_page = settings.CurrentPage;
});
}
base.OnAfterRender(firstRender);
}

protected override async Task OnInitializedAsync()
{
_order = ViewOrdersUseCase.Execute(user);
_ordersDto = Mapper.ProjectTo(_order);

SelectedOrders = new List { _ordersDto.FirstOrDefault() };

}

private async Task RowClick(DataGridRowMouseEventArgs mouseClick)
{
await _grid!.ExpandRow(mouseClick.Data);
SelectedOrders = _ordersDto.Where(o => o.Id == mouseClick.Data.Id).ToList();

if (SelectedOrders.Count > 0)
{
if (SelectedOrders[0].Status == "Completed" || SelectedOrders[0].Status == "Cancelled")
{
_detailToInsert = new OrderDetailDto();
}
else
{
_detailToInsert = null;
}
}
}

// Add a method to find the parent OrderDto of a given OrderDetailDto
private OrderDto? GetParentOrder(OrderDetailDto detail)
{
return _ordersDto.FirstOrDefault(o => o.OrderDetailsDto.Any(d =>  d.Id == detail.Id));
}

private async Task OnCreateRowDetail(OrderDetailDto? orderDetail)
{
if (orderDetail != null)
{
orderDetailMap = new OrderDetail();
Mapper.Map(orderDetail, orderDetailMap);

// Add the new order detail to the database
var addedOrderDetail = await AddOrderDetailUseCase.ExecuteAsync(orderDetailMap);

Mapper.Map(addedOrderDetail, orderDetail);
// Find the parent order
var parentOrder = GetParentOrder(orderDetail);

if (parentOrder != null)
{
pageIndex = current_page;
_order = ViewOrdersUseCase.Execute(user);
_ordersDto = Mapper.ProjectTo(_order);

await _gridDetail.GoToPage((int)pageIndex);
await _grid.ExpandRow(_ordersDto.FirstOrDefault(o => o.Id == parentOrder.Id));
}
}
}

private async Task OnUpdateRowDetail(OrderDetailDto orderDetail)
{
if (orderDetail == _detailToInsert)
{
_detailToInsert = null;
}

if (orderDetail != null)
{
orderDetailMap = new OrderDetail();
Mapper.Map(orderDetail, orderDetailMap);

// Update the order detail in the database
var updatedOrderDetail = await EditOrderDetailUseCase.ExecuteAsync(orderDetailMap);

// Find the parent order
var parentOrder = GetParentOrder(orderDetail);

if (parentOrder != null)
{
parentOrder.OrderDetailsDto = Mapper.Map(
await ViewOrderDetailsByOrderIdUseCase.ExecuteAsync(parentOrder.Id)
);

// Notify Blazor of the changes
StateHasChanged();
}
}
}

async Task EditRowDetail(OrderDetailDto orderDetail)
{
await _gridDetail.EditRow(orderDetail);
}

async Task SaveRowDetail(OrderDetailDto orderDetail)
{
await _gridDetail.UpdateRow(orderDetail);

if (orderDetail.ProductCode != null)
{
if (orderDetail == _detailToInsert)
{
_detailToInsert = null;
}
}

await _gridDetail.ExpandRow(orderDetail);
StateHasChanged();
}
}

public interface IViewOrdersUseCase
{
IQueryable Execute(ClaimsPrincipal user);
}

public class ViewOrdersUseCase : IViewOrdersUseCase
{
private readonly IOrderRepository _orderRepository;

public ViewOrdersUseCase(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}

public IQueryable Execute(ClaimsPrincipal user)
{
return _orderRepository.GetOrders(user);
}
}

public interface IOrderRepository
{
IQueryable GetOrders(ClaimsPrincipal user);
}

public class OrderRepository : IOrderRepository
{
private readonly IDbContextFactory _db;

public OrderRepository(IDbContextFactory db)
{ _db = db; }

public IQueryable GetOrders(ClaimsPrincipal user)
{
var ctx = _db.CreateDbContext();
IQueryable result = ctx.Orders
.Include(d => d.OrderDetails.Where(od => od.IsActive == 1))
.OrderByDescending(s => s.Id);

if (!user.IsInRole("Administrators"))
{
result = result.Where(u => u.DoneBy == user.Identity.Name);
}

return result;
}
}

public interface IAddOrderDetailUseCase
{
Task ExecuteAsync(CoreBusiness.OrderDetail orderDetail);
}

public class AddOrderDetailUseCase : IAddOrderDetailUseCase
{
private readonly IOrderDetailRepository _orderDetailRepository;

public AddOrderDetailUseCase(IOrderDetailRepository orderDetailRepository)
{
this._orderDetailRepository = orderDetailRepository;
}
public async Task  ExecuteAsync(OrderDetail orderDetail)
{
return await _orderDetailRepository.AddOrderDetailAsync(orderDetail);
}
}

public interface IOrderDetailRepository
{
Task AddOrderDetailAsync(OrderDetail orderDetail);

Task UpdateOrderDetailAsync(OrderDetail orderDetail);
}

public class OrderDetailRepository : IOrderDetailRepository
{
private readonly IDbContextFactory _db;

public OrderDetailRepository(IDbContextFactory db)
{
_db = db;
}

public async Task AddOrderDetailAsync(OrderDetail orderDetail)
{
await using var ctx = await _db.CreateDbContextAsync();
if (ctx.OrdersDetail.Any(x =>
x.Id == orderDetail.Id)) return null;

//Calculated Fields
orderDetail.TotalBuyPrice = orderDetail.BuyUnitPrice * orderDetail.Quantity;
orderDetail.TotalSellPrice = orderDetail.Quantity * orderDetail.SellUnitPrice;
orderDetail.UnitCost = orderDetail.BuyUnitPrice * (orderDetail.CostRatio / 100) + orderDetail.BuyUnitPrice;
orderDetail.TotalUnitCost = orderDetail.Quantity * orderDetail.UnitCost;
orderDetail.IsActive = 1; //Active
orderDetail.PaymentStatus = "Pending Payment";
orderDetail.Status = "Order Opened";

ctx.OrdersDetail.Add(orderDetail);
await ctx.SaveChangesAsync();

return orderDetail;
}

public async Task UpdateOrderDetailAsync(OrderDetail orderDetail)
{
await using var ctx = await _db.CreateDbContextAsync();
//detail
var detail = await ctx.OrdersDetail
.Include(v => v.Vendor)
.Include(o => o.Order)
.SingleAsync(x => x.Id == orderDetail.Id);

//Order Statuses
var statusCompleted = await ctx.OrdersDetail
.Where(x => x.OrderId == orderDetail.OrderId && x.Id != orderDetail.Id)
.AllAsync(c => c.Status == "Completed");
var statusContinues = await ctx.OrdersDetail
.Where(x => x.OrderId == orderDetail.OrderId && x.Id != orderDetail.Id)
.AnyAsync(c => c.Status != "Completed");

if (orderDetail != null && detail != null && vendor != null)
{
detail.Quantity = orderDetail.Quantity;
detail.CostRatio = orderDetail.CostRatio;
detail.Description = orderDetail.Description;
detail.ProductCode = orderDetail.ProductCode;
detail.ProductName = orderDetail.ProductName;
detail.BuyUnitPrice = orderDetail.BuyUnitPrice;
detail.ShippingNumber = orderDetail.ShippingNumber;
detail.ShippingWeek = orderDetail.ShippingWeek;
detail.Status = orderDetail.Status;
detail.TotalBuyPrice = orderDetail.BuyUnitPrice * orderDetail.Quantity;
detail.TotalSellPrice = orderDetail.Quantity * orderDetail.SellUnitPrice;
detail.SellUnitPrice = orderDetail.SellUnitPrice;
detail.UnitCost = orderDetail.BuyUnitPrice * (orderDetail.CostRatio / 100) + orderDetail.BuyUnitPrice;
detail.TotalUnitCost = detail.UnitCost * orderDetail.Quantity;
detail.Currency = orderDetail.Currency;
detail.CustomerOrderNumber = orderDetail.CustomerOrderNumber;
detail.CustomerStockCode = orderDetail.CustomerStockCode;
detail.OrderId = orderDetail.OrderId;
detail.TrackingNumber = orderDetail.TrackingNumber;
detail.Warehouse = orderDetail.Warehouse;
detail.PoNotes = orderDetail.PoNotes;
detail.PaymentStatus = orderDetail.PaymentStatus;
if (statusCompleted &&  orderDetail.Status == "Completed")
detail.Order.Status = "Completed";
if (statusContinues || orderDetail.Status != "Completed")
detail.Order.Status = "Continues";
detail.Vendor = vendor;

if (detail.Status == "Completed")
{
detail.CompletionDateTime = orderDetail.CompletionDateTime ?? DateTime.Now.Date;
}
else
{
detail.CompletionDateTime = null;
}

ctx.OrdersDetail.Update(detail);
await ctx.SaveChangesAsync();
}

return detail;
}

public async Task GetOrderDetailsByOrderId(int orderId)
{
await using var ctx = await _db.CreateDbContextAsync();
return await ctx.OrdersDetail
.Where(x => x.OrderId == orderId && x.IsActive == 1)
.Include(x => x.Order).ToListAsync();
}
}

public interface IEditOrderDetailUseCase
{
Task ExecuteAsync(CoreBusiness.OrderDetail orderDetail);
}

public class EditOrderDetailUseCase : IEditOrderDetailUseCase
{
private readonly IOrderDetailRepository _orderDetailRepository;

public EditOrderDetailUseCase(IOrderDetailRepository orderDetailRepository)
{
this._orderDetailRepository = orderDetailRepository;
}

public async Task ExecuteAsync(OrderDetail orderDetail)
{
return await _orderDetailRepository.UpdateOrderDetailAsync(orderDetail);
}
}

public interface IViewOrderDetailsByOrderIdUseCase
{
Task ExecuteAsync(int orderId);
}

public class ViewOrderDetailsByOrderIdUseCase : IViewOrderDetailsByOrderIdUseCase
{
private readonly IOrderDetailRepository _orderDetailRepository;
public ViewOrderDetailsByOrderIdUseCase(IOrderDetailRepository orderDetailRepository)
{
_orderDetailRepository = orderDetailRepository;
}

public async Task ExecuteAsync(int orderId)
{
return await _orderDetailRepository.GetOrderDetailsByOrderId(orderId);
}
}

public class OrderDto
{
public int Id { get; set; }
public DateTime OrderDateTime { get; set; }
public int CustomerId { get; set; }
public string Status { get; set; }
public string DoneBy { get; set; }
public List OrderDetailsDto { get; set; }
}

public class Order
{

public int Id { get; set; }

[Required]
public DateTime OrderDateTime { get; set; }
[Required]
[MaxLength(250)]
public int CustomerId { get; set; }
public string Status { get; set; }
[MaxLength(50)]
public string DoneBy { get; set; }
public List OrderDetails { get; set; }
}

public class OrderDetailDto
{
public int Id { get; set; }
public string ProductCode { get; set; }
public string? ProductName { get; set; }
public int Quantity { get; set; }
public double BuyUnitPrice { get; set; }
public double CostRatio { get; set; }
public double UnitCost { get; set; }
public double TotalBuyPrice { get; set; }
public double? SellUnitPrice { get; set; }
public double? TotalSellPrice { get; set; }
public string? ShippingNumber { get; set; }
public string? Status { get; set; }
public string? TrackingNumber { get; set; }
public string? Description { get; set; }
public string? Currency { get; set; }
public string? CustomerStockCode { get; set; }
public string? CustomerOrderNumber { get; set; }
public int IsActive { get; set; }
public double? TotalUnitCost { get; set; }
public int OrderId { get; set; }
public int VendorId { get; set; }
public string? Warehouse { get; set; }
public string? PaymentStatus { get; set; }
public OrderDto OrderDto { get; set; }
public DateTime? CompletionDateTime { get; set; }
public int? ShippingWeek { get; set; }
public string? PoNotes { get; set; }
}

public class OrderDetail
{
public int Id { get; set; }

[Required]
[MaxLength(100)]
public string ProductCode { get; set;  }

[MaxLength(250)]
public string? ProductName { get; set; }

[Required]
public int Quantity { get; set; }

[Required]
public double BuyUnitPrice { get; set; }

public double CostRatio { get; set; }
public double UnitCost { get; set; }
public double TotalBuyPrice { get; set; }
public double? SellUnitPrice { get; set; }
public double? TotalSellPrice { get; set; }

[MaxLength(150)]
public string? ShippingNumber { get; set; }

public string? Status { get; set; }

[MaxLength(150)]
public string? TrackingNumber { get; set; }

[MaxLength(400)]
public string? Description { get; set; }

public string? Currency { get; set; }
public string? CustomerStockCode { get; set; }
public string? CustomerOrderNumber { get; set; }
public int IsActive { get; set; }
public double? TotalUnitCost { get; set; }
public int OrderId { get; set; }
public int VendorId { get; set; }
public string? Warehouse { get; set; }
public string? PaymentStatus { get; set; }
public Order Order { get; set; }

[DataType(DataType.DateTime)]
public DateTime? CompletionDateTime { get; set; }

public int? ShippingWeek { get; set; }
public string? PoNotes { get; set; }
}

Почему строка не расширяется? _ordersDto.FirstOrDefault(o => o.Id ==parentOrder.Id) возвращает действительный заказ с новыми добавленными деталями.


Подробнее здесь: https://stackoverflow.com/questions/790 ... -a-new-row