public void ReplaceRow(int ndxItem, T newItem)
{
Debug.Assert(IsConnected);
Debug.Assert(ndxItem >= 0);
Debug.Assert(ndxItem < RowCount);
Debug.Assert(newItem != null);
lock (m_rwLock)
{
T oldItem = GetRow(ndxItem);
RowReplacing?.Invoke(ndxItem, oldItem);
int ndx = DoReplace(ndxItem, newItem);
Header.LastAccessTime = Header.LastWriteTime = DateTime.Now;
if (ndx != ndxItem)
{
RowDeleted?.Invoke(ndxItem);
RowInserted?.Invoke(ndx, newItem);
}
else
{
RowReplaced?.Invoke(ndx, newItem);
}
}
}
protected void Table_RowDeleted(object sender, DataRowChangeEventArgs e)
{
if (!programmaticUpdate)
{
IEntity item = items.SingleOrDefault(record => ((MappedRecord)record).Row == e.Row);
if (item != null)
{
RowDeletedEventArgs args = new RowDeletedEventArgs()
{
Entity = item
};
RowDeleted.Fire(this, args);
if (!args.Handled)
{
items.Remove(item);
Delete(item);
RowDeleteFinalized.Fire(this, new RowDeleteFinalizedEventArgs()
{
Entity = item
});
}
}
}
}
public void DeleteRow(int ndxItem)
{
Debug.Assert(IsConnected);
Debug.Assert(ndxItem >= 0);
Debug.Assert(ndxItem < RowCount);
lock (m_rwLock)
{
RowDeleting?.Invoke(ndxItem);
DoDelete(ndxItem);
Header.LastWriteTime = Header.LastAccessTime = DateTime.Now;
RowDeleted?.Invoke(ndxItem);
}
}
protected virtual void OnRowDeleted(EventArgs e)
{
RowDeleted?.Invoke(this, e);
}
public void OnRowDeleted(T t)
{
State = TableState.Changed;
RowDeleted?.Invoke(this, new RowEventArgs <T>(t));
}
private void UpdateFreeItemLines(CRServiceCase current)
{
var groupedByInventory = new Dictionary <int, decimal>();
foreach (CRServiceCaseDiscountDetail item in
PXSelect <CRServiceCaseDiscountDetail,
Where <CRServiceCaseDiscountDetail.serviceCaseID, Equal <Required <CRServiceCaseDiscountDetail.serviceCaseID> > > > .
Select(this, current.ServiceCaseID))
{
if (item.FreeItemID != null)
{
var val = item.FreeItemQty ?? 0;
if (groupedByInventory.ContainsKey(item.FreeItemID.Value))
{
groupedByInventory[item.FreeItemID.Value] += val;
}
else
{
groupedByInventory.Add(item.FreeItemID.Value, val);
}
}
}
bool freeItemChanged = false;
RowDeleted.RemoveHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowDeleted);
RowInserted.RemoveHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowInserted);
RowUpdated.RemoveHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowUpdated);
try
{
foreach (CRServiceCaseItem line in FreeItems.Select())
{
if (line.ManualDiscount == false && line.InventoryID != null)
{
if (groupedByInventory.ContainsKey(line.InventoryID.Value))
{
if (groupedByInventory[line.InventoryID.Value] == 0)
{
FreeItems.Delete(line);
freeItemChanged = true;
}
}
else
{
FreeItems.Delete(line);
freeItemChanged = true;
}
}
}
int?defaultWarehouse = GetDefaultWarehouse();
foreach (KeyValuePair <int, decimal> kv in groupedByInventory)
{
CRServiceCaseItem freeLine = GetFreeLineByItemID(kv.Key, current.ServiceCaseID);
if (freeLine == null)
{
if (kv.Value > 0)
{
var line = new CRServiceCaseItem();
line.InventoryID = kv.Key;
line.IsFree = true;
line.SiteID = defaultWarehouse;
line.ActualQuantity = kv.Value;
FreeItems.Insert(line);
freeItemChanged = true;
}
}
else
{
freeLine.ActualQuantity = kv.Value; //TODO: need set other fields
FreeItems.Update(freeLine);
freeItemChanged = true;
}
}
}
finally
{
RowDeleted.AddHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowDeleted);
RowInserted.AddHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowInserted);
RowUpdated.AddHandler(typeof(CRServiceCaseItem), CRServiceCaseItem_RowUpdated);
}
if (freeItemChanged)
{
Details.View.RequestRefresh();
}
}
