Refactoring was made and imporved working speed

BankOperationsUpdate.WorkerService/Data/Models/Enum/Status.cs

@@ -6,6 +6,8 @@ public enum Status
 	NEW,
 	CONFIRMED,
 	CANCELED,
+	DELETED,
+	CHANGED,
 
 }
 

BankOperationsUpdate.WorkerService/Data/Models/TransactionsDTO.cs

@@ -11,5 +11,6 @@ public class TransactionsDTO
 	public decimal BalanceAmount { get; set; }
 	public bool IsChanged { get; set; }
 	public long OperationOrderId { get; set; }
+    public decimal ChangedDifference { get; set; }
 }
 

BankOperationsUpdate.WorkerService/OperationsUpdate/UpdateOperations.cs

@@ -1,5 +1,6 @@
 
 
+using System.Collections.ObjectModel;
 using System.Security;
 
 namespace BankOperationsUpdate.WorkerService.OperationsUpdate;
@@ -62,7 +63,7 @@ public  class UpdateOperations
 
 			_logger.LogDebug("Process for account {0}", bankBalances[i].Id);
 
-			SetTransactionsForAccount(bankBalances[i]!.BankAccountId.Value, bankBalances[i]!.BusinessId.Value);
+			SetTransactionsForAccount(bankBalances[i].BankAccountId!.Value, bankBalances[i].BusinessId!.Value);
 
 		}
 	}
@@ -76,7 +77,7 @@ public  class UpdateOperations
 		//get all operations with New status 
 		var newOperations = GetAllNewOperations().OrderBy(x => x.DocDate).ThenBy(x => x.OrderId).ToList();
 		//get all bankOperationIds that added to transactions
-		var transactiondHashSet = GetAllTransactions().Select(x => x.BankOperationId).ToHashSet();
+		var transactiondHashSet = GetAllTransactions().Select(x => x.BankOperationId).Distinct().ToList();
 
 		BankAccountBalance accountBalance;
 		Transaction transaction;
@@ -88,7 +89,7 @@ public  class UpdateOperations
 				try {
 					accountBalance = GetAccountBalanceByBusinessId(item.BankAccountId!.Value, item.BusinessId!.Value);
 					//change balance on certain amount
-					accountBalance.Amount = accountBalance.Amount!.Value + item.IncomeAmount!.Value - item.OutcomeAmount!.Value;
+					accountBalance.Amount = accountBalance.Amount!.Value + item.IncomeAmount - item.OutcomeAmount;
 
 					//create new transaction
 					transaction = new Transaction {
@@ -96,13 +97,15 @@ public  class UpdateOperations
 						BankOperationId = item.Id,
 						IncomeAmount = item.IncomeAmount,
 						OutcomeAmount = item.OutcomeAmount,
-						BalanceAmount = item.IncomeAmount!.Value - item.OutcomeAmount!.Value,
+						BalanceAmount = 0,
 						ModifiedDate = item.DocDate,
 						BusinessId = item.BusinessId.Value,
 						BankAccountId = item.BankAccountId.Value,
 						CreateDate = DateTime.Now,
 						OperationCreateDate = item.CreatedDate ?? item.DocDate!.Value,
-						IsChanged = true,
+						//IsChanged = true,
+						Status = Status.NEW.ToString(),
+						ChangedDifference = item.IncomeAmount - item.OutcomeAmount,
 						OperationOrderId = item.OrderId,
 					};
 
@@ -118,6 +121,7 @@ public  class UpdateOperations
 				}
 			
 			}
+			//if transactions have already contained opearation but it was changed
 			else if(transactiondHashSet.Contains(item.Id) && item.IsChanged == true) {
 				UpdateChangedOperations(item, true);
 			}
@@ -143,50 +147,55 @@ public  class UpdateOperations
 		//if it is bankOperation with new status that already was in transatctions
 		if (!IsChanged) {
 			 //get the income or outcome sum of rollBackcked transaction
-			incomeDifference = -1 * transaction.IncomeAmount.Value;
-			outcomeDifference = -1 * transaction.OutcomeAmount.Value;
-			_repositoryWrapper.Transaction.Delete(transaction);
+			incomeDifference = -1 * transaction.IncomeAmount;
+			outcomeDifference = -1 * transaction.OutcomeAmount;
+			transaction.BalanceAmount = 0;
+			transaction.Status = Status.DELETED.ToString();
+
 		}
 		//else if it is confirmed transaction that has already in transactions
 		else {
 			 //get the income or outcome difference that opertion was changed
-			incomeDifference = operation.IncomeAmount.Value - transaction.IncomeAmount.Value;
-			outcomeDifference = operation.OutcomeAmount.Value - transaction.OutcomeAmount.Value;
+			incomeDifference = operation.IncomeAmount - transaction.IncomeAmount;
+			outcomeDifference = operation.OutcomeAmount - transaction.OutcomeAmount;
+			transaction.Status = Status.CHANGED.ToString();
 
-			transaction.IncomeAmount += incomeDifference;
-			transaction.OutcomeAmount += outcomeDifference;
-			operation.IsChanged = false;
+		}
 
-			_logger.LogInformation("Updated transaction with id: {0}", transaction.Id);
-			_repositoryWrapper.Transaction.Update(transaction);
-			_repositoryWrapper.BankOperation.Update(operation);
+        transaction.IncomeAmount += incomeDifference;
+        transaction.OutcomeAmount += outcomeDifference;
+		transaction.ChangedDifference += incomeDifference - outcomeDifference;
+        //transaction.IsChanged = true;
+        operation.IsChanged = false;
 
-		}
 
-		accountBalance.Amount = accountBalance.Amount + incomeDifference - outcomeDifference;
-		_repositoryWrapper.BankAccountBalance.Update(accountBalance);
+        accountBalance.Amount = accountBalance.Amount + incomeDifference - outcomeDifference;
+       
+		_repositoryWrapper.Transaction.Update(transaction);
+        _repositoryWrapper.BankOperation.Update(operation);
+        _repositoryWrapper.BankAccountBalance.Update(accountBalance);
 		_repositoryWrapper.Save();
 		_repositoryWrapper.Transaction.Detach(transaction);
         _repositoryWrapper.BankAccountBalance.Detach(accountBalance);
 
 
-        //get the transactions that come after modified transaction and change their balanceAmount on cahnged certain amount
-        var transactionsList = GetTransactionsByAccountId(operation.BankAccountId.Value, operation.BusinessId.Value)
-			.Where(x => x.BusinessId == operation.BusinessId && 
-				x.BankAccountId == operation.BankAccountId && 
-				DateTime.Compare(x.ModifiedDate.Value, transaction.ModifiedDate.Value) >= 0)
-			.OrderBy(x => x.ModifiedDate)
-			.ThenBy(x => x.OperationOrderId).ToList();	 
-
-		foreach(var item  in transactionsList) {
-			item.BalanceAmount = item.BalanceAmount + incomeDifference - outcomeDifference;
-			_logger.LogInformation("Updated transaction with id: {0}", transaction.Id);
-			_repositoryWrapper.Transaction.Update(item);
-			_repositoryWrapper.Save();
-			_repositoryWrapper.Transaction.Detach(item);
-		}
+  //      //get the transactions that come after modified transaction and change their balanceAmount on cahnged certain amount
+  //      var transactionsList = GetTransactionsByAccountId(operation.BankAccountId.Value, operation.BusinessId.Value)
+		//	.Where(x => x.BusinessId == operation.BusinessId && 
+		//		x.BankAccountId == operation.BankAccountId && 
+		//		DateTime.Compare(x.ModifiedDate.Value, transaction.ModifiedDate.Value) >= 0)
+		//	.OrderBy(x => x.ModifiedDate)
+		//	.ThenBy(x => x.OperationOrderId).ToList();	 
 
-	}
+		//foreach(var item  in transactionsList) {
+		//	item.BalanceAmount = item.BalanceAmount + incomeDifference - outcomeDifference;	
+		//}
+
+  //      _repositoryWrapper.Transaction.UpdateBulk(transactionsList);
+  //      _repositoryWrapper.Save();
+		//_repositoryWrapper.Transaction.DetachBulk(transactionsList);
+
+    }
 
 
 	//update all new added transactions for updating balance amount of items that comes after updated  item
@@ -194,24 +203,55 @@ public  class UpdateOperations
 	{
 		var bankAccounts = GetAllBankBalances().ToList();
 		List<Transaction> transactions;
-		decimal newValue = 0M;
+		decimal changedAmount;
 
 		foreach (var account in bankAccounts) {
-			transactions = GetTransactionsByAccountId(account.BankAccountId!.Value, account.BusinessId!.Value).OrderBy(x => x.ModifiedDate).ThenBy(x => x.OperationOrderId).ToList();
 
-			for (int i = 1; i < transactions.Count; i++) {
-				if (transactions[i].IsChanged == true) {
-					transactions[i].BalanceAmount += transactions[i - 1].BalanceAmount;
-					newValue += transactions[i].IncomeAmount!.Value - transactions[i].OutcomeAmount!.Value;
-					transactions[i].IsChanged = false;
-				}
-				else {
-					transactions[i].BalanceAmount += newValue;
-				}
-
-				_repositoryWrapper.Transaction.Update(transactions[i]);
-				_repositoryWrapper.Save();
-			}
+			var allTransactions = GetTransactionsByAccountId(account.BankAccountId!.Value, account.BusinessId!.Value);
+			List<Transaction> removedTransactions = new();
+
+			//check if transactions contains isChange element
+			if (allTransactions.Any(x => !x.Status.Equals(Status.CONFIRMED.ToString()))) {
+				//order transactions by DocDate and OperationOrderId
+				transactions = allTransactions.OrderBy(x => x.ModifiedDate).ThenBy(x => x.OperationOrderId).ToList();
+				//get the index of the first occurance of element with IsChanged = true
+				int changedIndex = transactions.FindIndex(x => !x.Status.Equals(Status.CONFIRMED.ToString()));
+                changedAmount = 0M;
+
+                for (int i = changedIndex; i < transactions.Count && changedIndex != -1; i++) {
+
+                    //added changed amount
+                    changedAmount += transactions[i].ChangedDifference;
+
+                    if (!transactions[i].Status.Equals(Status.DELETED.ToString())) {
+						if (transactions[i].Status.Equals(Status.NEW.ToString())) {
+							transactions[i].BalanceAmount += i > 0 ? transactions[i - 1].BalanceAmount : 0;
+
+							//if record is added newly then add to balance previous balance and changed difference
+							transactions[i].BalanceAmount += transactions[i].ChangedDifference; 
+						}
+						else {
+                            transactions[i].BalanceAmount += changedAmount;
+                        }
+
+						//reset changed difference of transaction
+						transactions[i].ChangedDifference = 0;
+						//set status of processed transaction to confirmed
+                        transactions[i].Status = Status.CONFIRMED.ToString();
+					}
+					else {
+						removedTransactions.Add(transactions[i]);
+                        transactions.RemoveAt(i);
+						i--;
+                    }
+
+                }
+
+                _repositoryWrapper.Transaction.UpdateBulk(transactions);
+                _repositoryWrapper.Transaction.DeleteBulk(removedTransactions);
+                _repositoryWrapper.Save();
+                _repositoryWrapper.Transaction.DetachBulk(transactions);
+            }
 		}
 	}
 
@@ -227,41 +267,45 @@ public  class UpdateOperations
 		var operations =  GetAllConfirmedOperations(accountId, businessId).OrderBy(x => x.DocDate).ThenBy(x => x.OrderId).ToList();
 		
 		// get Unitque bankOpertionsIds from transatctions 
-		var transactionsHashSet = GetTransactionsByAccountId(accountId, businessId).Select(x => x.BankOperationId).ToHashSet();
-		Transaction transaction = new Transaction();
+		var transactionsDistinct = GetTransactionsByAccountId(accountId, businessId).Select(x => x.BankOperationId).Distinct().ToList();
+		ICollection<Transaction> transactions = new Collection<Transaction>();
 
 		//get current balance by summarizing all Incomes and outcomes from transacitons
-		var currentBalance = GetTransactionsByAccountId(accountId, businessId).Sum(x => (x.IncomeAmount - x.OutcomeAmount));
-											   
+		var currentBalance = 0M;
 
-		for (int i = 0; i < operations.Count && transactionsHashSet.Count == 0; i++) {
+		for (int i = 0; i < operations.Count && transactionsDistinct.Count == 0; i++) {
 
 			//if BankOperationsIds doesn't contain confirmed operations then..
-			if (!transactionsHashSet.Contains(operations[i].Id) ) {
+			if (!transactionsDistinct.Contains(operations[i].Id)) {
 
 				//change balance on certain income or outcome amount
-				currentBalance = currentBalance + operations[i].IncomeAmount!.Value - operations[i].OutcomeAmount!.Value;
-
-				transaction.Id = Guid.NewGuid();
-				transaction.IncomeAmount = operations[i].IncomeAmount;
-				transaction.OutcomeAmount = operations[i].OutcomeAmount;
-				transaction.BankOperationId = operations[i].Id;
-				transaction.IsChanged = false;
-				transaction.ModifiedDate = operations[i].DocDate;
-				transaction.BusinessId = businessId;
-				transaction.BankAccountId = accountId;
-				transaction.CreateDate = DateTime.Now;
-                transaction.OperationCreateDate = operations[i].CreatedDate ?? transaction.ModifiedDate!.Value;
-                transaction.BalanceAmount = currentBalance ?? 0;
-				transaction.OperationOrderId = operations[i].OrderId;
-
-				//create transaction
-				_repositoryWrapper.Transaction.Create(transaction);
-				_repositoryWrapper.Save();
+				currentBalance = currentBalance + operations[i].IncomeAmount - operations[i].OutcomeAmount;
+
+				transactions.Add(new Transaction{
+					Id = Guid.NewGuid(),
+					IncomeAmount = operations[i].IncomeAmount,
+					OutcomeAmount = operations[i].OutcomeAmount,
+					BankOperationId = operations[i].Id,
+					IsChanged = false,
+					ModifiedDate = operations[i].DocDate,
+					BusinessId = businessId,
+					BankAccountId = accountId,
+					CreateDate = DateTime.Now,
+					OperationCreateDate = operations[i].CreatedDate ?? operations[i].DocDate!.Value,
+					BalanceAmount = currentBalance,
+					OperationOrderId = operations[i].OrderId,
+					ChangedDifference = 0,
+					Status = Status.CONFIRMED.ToString(),
+				});
+
 			}
-		}
 
-		_logger.LogInformation($"{operations.Count} count records was written");
+        }
+
+        //create transaction
+        _repositoryWrapper.Transaction.CreateBulk(transactions);
+        _repositoryWrapper.Save();
+        _logger.LogInformation($"{operations.Count} count records was written");
 
 	}
 

BankOperationsUpdate.WorkerService/appsettings.json

@@ -11,7 +11,7 @@
     }
   },
 
-  "RefreshInterval" : "5"
+  "RefreshInterval" : "1"
 
 
 }

Contracts/IRepositoryBase.cs

@@ -10,7 +10,11 @@ public interface IRepositoryBase<T>
     IQueryable<T> FindAll();
     IQueryable<T> FindByCondition(Expression<Func<T, bool>> expression);
     void Create(T entity);
+    void CreateBulk(ICollection<T> entities);
+    void UpdateBulk(ICollection<T> entities);
     void Update(T entity);
     void Delete(T entity);
+    void DeleteBulk(ICollection<T> entities);
     void Detach(T entity);
+    void DetachBulk(ICollection<T> entities);
 }

Entities/Models/BankOperation.cs

@@ -25,8 +25,8 @@ namespace Entities.Models
         public Guid? BankAccountId { get; set; }
         public Guid? CashOperationTypeId { get; set; }
         public Guid? CustomerId { get; set; }
-        public decimal? IncomeAmount { get; set; }
-        public decimal? OutcomeAmount { get; set; }
+        public decimal IncomeAmount { get; set; }
+        public decimal OutcomeAmount { get; set; }
         public string? Purpose { get; set; }
         public Guid? OperationPurposeId { get; set; }
         public Guid? IncomeItemsCollectionId { get; set; }

Entities/Models/Transaction.cs

@@ -9,8 +9,8 @@ namespace Entities.Models
         public Guid? CollectionId { get; set; }
         public int Version { get; set; }
         public Guid BankOperationId { get; set; }
-        public decimal? IncomeAmount { get; set; }
-        public decimal? OutcomeAmount { get; set; }
+        public decimal IncomeAmount { get; set; }
+        public decimal OutcomeAmount { get; set; }
         public decimal BalanceAmount { get; set; }
         public long OperationOrderId { get; set; }
         public bool IsChanged { get; set; }
@@ -19,6 +19,8 @@ namespace Entities.Models
         public Guid BusinessId { get; set; }
         public DateTime CreateDate { get; set; }
         public DateTime OperationCreateDate { get; set; }
+        public decimal ChangedDifference { get; set; }
+        public string Status { get; set; }
 
         public virtual BankOperation BankOperation { get; set; } = null!;
     }

Entities/RepositoryContext.cs

@@ -91,7 +91,13 @@ namespace Entities
 
 				entity.Property(e => e.OutcomeAmount).HasPrecision(18, 2);
 
-				entity.Property(e => e.ModifiedDate).HasColumnType("timestamp without time zone");
+                entity.Property(e => e.ChangedDifference).HasPrecision(18, 2);
+
+                entity.Property(e => e.Status).HasMaxLength(30);
+
+                entity.Property(e => e.IsChanged);
+
+                entity.Property(e => e.ModifiedDate).HasColumnType("timestamp without time zone");
 
 				entity.Property(e => e.CreateDate).HasColumnType("timestamp without time zone");
 

Repository/BankOperationRepository.cs

@@ -25,8 +25,8 @@ public class BankOperationRepository : RepositoryBase<BankOperation>, IBankOpera
 	public IQueryable<BankOperation> GetAllNew(Guid accountId, Guid businessId)
 	{
 		if(accountId == Guid.Empty)
-			return FindByCondition(x => x.Status == "NEW");
-		return FindByCondition(x => x.Status == "NEW" && x.BankAccountId == accountId && x.BusinessId == businessId);
+			return FindByCondition(x => !x.Status!.Equals("CONFIRMED"));
+		return FindByCondition(x => !x.Status!.Equals("CONFIRMED") && x.BankAccountId == accountId && x.BusinessId == businessId);
 
 	}
 

Repository/RepositoryBase.cs

@@ -20,7 +20,17 @@ public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class
     public IQueryable<T> FindByCondition(Expression<Func<T, bool>> expression) =>
         RepositoryContext.Set<T>().Where(expression).AsNoTracking();
     public void Create(T entity) => RepositoryContext.Set<T>().Add(entity);
+    public void CreateBulk(ICollection<T> entities) => RepositoryContext.Set<T>().AddRange(entities);
+    public void UpdateBulk(ICollection<T> entities) => RepositoryContext.Set<T>().UpdateRange(entities);
     public void Update(T entity) => RepositoryContext.Set<T>().Update(entity);
     public void Delete(T entity) => RepositoryContext.Set<T>().Remove(entity);
+    public void DeleteBulk(ICollection<T> entities) => RepositoryContext.Set<T>().RemoveRange(entities);
     public void Detach(T entity) => RepositoryContext.Entry(entity).State = EntityState.Detached;
+
+    public void DetachBulk(ICollection<T> entities)
+    {
+        foreach (var item in entities) {
+            RepositoryContext.Entry(item).State = EntityState.Detached;
+        }
+    }
 }