public TotalsItemTableEntity(TotalsSearchItem searchItem)
        {
            this.PartitionKey = string.Empty;
            this.RowKey = searchItem.DocUniqueID;

            this.ClientInternalID = searchItem.ClientInternalID;
            this.MvaNumber = searchItem.MvaNumber;
            this.CustomerNumber = searchItem.CustomerNumber;
            this.ProductID = searchItem.ProductID;
            this.Date = searchItem.Date;
            this.Amount = searchItem.Amount;
        }
        private static async Task ProcessTransactions(SearchRepository sRepo, TransactionRepository tRepo, Customer customer, string productID, int? dateVal)
        {
            //any transaction newer than 'dtLimit' should not be processed because it's kept as an individual search item
            DateTime dtLimit = DateTime.UtcNow.Date.AddDays(-Constants.DaysToKeepTransactions);
            
            int curDateVal;
            if(dateVal.HasValue)
            {
                curDateVal = dateVal.Value;
            }
            else
            {
                curDateVal = int.Parse(dtLimit.AddDays(-1).ToString(Constants.DateStringFormat));
            }

            var existingItems = sRepo.GetTotalsItemsForCustomer(customer.InternalID.Value, productID, curDateVal);
            HashSet<string> existingItemIDs = new HashSet<string>(existingItems.Select(e => e.DocUniqueID));

            Dictionary<string, int> productTotals = new Dictionary<string, int>();

            var res =await  tRepo.GetTransactionsForCustomer(customer.InternalID.Value, curDateVal);
            if(!string.IsNullOrWhiteSpace(productID))
            {
                res = res.Where(r => r.ProductID == productID);
            }
            
            res = res.Where(r => r.DateTime < dtLimit);

            foreach (var transaction in res)
            {
                if (productTotals.ContainsKey(transaction.ProductID))
                {
                    productTotals[transaction.ProductID] = productTotals[transaction.ProductID] + transaction.Amount.Value;
                }
                else
                {
                    productTotals.Add(transaction.ProductID, transaction.Amount.Value);
                }
            }

            var searchItems = new List<TotalsSearchItem>();
            foreach (var entry in productTotals)
            {
                var newItem = new TotalsSearchItem
                {
                    DocUniqueID = TotalsSearchItem.CreateUID(curDateVal, entry.Key, customer.InternalID.Value),
                    ClientInternalID = customer.InternalID.Value.ToString(),
                    CustomerNumber = customer.CustomerNumber,
                    Date = curDateVal,
                    MvaNumber = customer.MvaNumber,
                    ProductID = entry.Key,
                    Amount = entry.Value
                };

                searchItems.Add(newItem);
                existingItemIDs.Remove(newItem.DocUniqueID);
            }

            sRepo.AddOrUpdateTotalsItem(searchItems.ToArray());
            tRepo.AddOrUpdateTransactionTotalsItem(searchItems.Select(item => new TotalsItemTableEntity(item)).ToArray());

            //in case a transaction was deleted, remove all totals items from search index that are no longer valid
            sRepo.DeleteTotalsItemWithID(existingItemIDs.ToArray());
            tRepo.DeleteTransactionTotalsItemWithID(existingItemIDs.ToArray());
        }