var legacyDetails = _migration.TransactionDetails

                        .Where(x => x.TransactionID.Equals(legacy.TransactionID))

                        .Where(x => x.DetailRowType.In("H", "M", "X"))

                        .OrderBy(x => x.DetailRowOrder)

                        .ToList();

​

                    // Remove the header - will be re-added

                    if (type.Equals(TransactionType.PayrollRemittance))

                    {

                        var header = legacyDetails.First();

                        header.DetailRowType = "H";

                    }

​

                    if (convertHistorical)

                    {

                        var header = legacyDetails

                            .Where(x => x.DetailRowType.Equals("H"))

                            .First();

​

                        legacyDetails.Clear();

​

                        var mandatoryAccountId = _migration.MandatoryAccountSettings

                            .First().RetainedEarningsAccountID;

​

                        // Convert to just a header and an 

                        // offset to retained earnings

                        legacyDetails.Add(header);

​

                        legacyDetails.Add(new Legacy.Models.TransactionDetails()

                        {

                            TransactionDetailType = "O",

                            AccountID = mandatoryAccountId,

                            Description = header.Description,

                            DetailRowType = "M",

                            Column = header.Column.Equals("C") ? "D" : "C",

                            Amount = header.Amount,

                        });

                    }

​

                    foreach (var legacyDetail in legacyDetails)

                    {

                        // Some header detail types will change

                        var detailType = Legacy.EnumConverters.TransactionDetailTypeForCode(legacyDetail.TransactionDetailType);

                        var number = (int?)null;

                        var personId = GetNewId(legacyDetail.ContactID);

​

                        if (legacyDetail.DetailRowType.Equals("H"))

                        {

​

                            switch (transaction.Type)

                            {

                                case TransactionType.BankTransfer:

                                    detailType = TransactionDetailType.BankTransfer;

                                    break;

                                case TransactionType.Deposit:

                                    detailType = TransactionDetailType.Deposit;

                                    if (string.IsNullOrEmpty(legacy.PSAContactID))

                                    {

                                        var cashSale = _migration.Contacts.SingleOrDefault(x => x.CompanyName.Equals("Cash Sale"));

                                        personId = GetNewId(cashSale.ContactID);

                                    }

                                    else

                                    {

                                        personId = GetNewId(legacy.PSAContactID);

                                    }

                                    break;

                                case TransactionType.Withdrawal:

                                    detailType = TransactionDetailType.Withdrawal;

                                    if (string.IsNullOrEmpty(legacy.PSAContactID))

                                    {

                                        var oneTimeSupplier = _migration.Contacts.SingleOrDefault(x => x.CompanyName.Equals("One Time Supplier"));

                                        personId = GetNewId(oneTimeSupplier.ContactID);

                                    }

                                    else

                                    {

                                        personId = GetNewId(legacy.PSAContactID);

                                    }

                                    break;

                            }

                        }

                        else

                        {

                            if (RequiresNumber(type))

                            {

                                number = nextNumber++;

                            }

                        }

​

                        var accountId = await GetNewAccountIdAsync(subscriptionId, legacyDetail.AccountID);

                        var account = await _dbContext.Accounts.SingleAsync(x => x.Id.Equals(accountId));

                        var multiplier = ColumnMultiplier(detailType, account, legacyDetail.Column);

​

                        // Create new detail

                        var detail = new TransactionDetail()

                        {

                            Number = number,

                            Type = detailType,

                            AccountId = accountId,

                            PersonId = personId,

                            Description = legacyDetail.Description,

                        };

​

                        // If screen amount exists - rebuild using that

                        if (type.In(TransactionType.GeneralJournal, TransactionType.Inventory, TransactionType.OpeningBalance) || legacyDetail.ScreenAmount.Equals(0M))

                        {

                            detail.Amount = legacyDetail.Amount * multiplier;

                            detail.Quantity = legacyDetail.Quantity * multiplier;

                        }

                        else

                        {

                            var taxType = Legacy.EnumConverters.TransactionDetailTaxforCode(legacyDetail.TaxCode);

                            var amount = 0M; //// GetPostAmount(taxRate.PstDetail, taxType, legacyDetail.ScreenGSTAmount, legacyDetail.ScreenPSTAmount, legacyDetail.ScreenAmount);

                            detail.AmountBeforeTax = legacyDetail.ScreenAmount * multiplier;

                            detail.Amount = amount * multiplier;

                            detail.GstAmount = legacyDetail.ScreenGSTAmount * multiplier;

                            detail.PstAmount = legacyDetail.ScreenPSTAmount * multiplier;

                            detail.Quantity = legacyDetail.Quantity * multiplier;

                        }

​

                        // Additional based on type

                        switch (detailType)

                        {

                            case TransactionDetailType.PayablePayment:

                            case TransactionDetailType.ReceivablePayment:

                                detail.PaymentForId = transactionIds[legacyDetail.TransactionIDBeingPaidOff];

                                break;

                            case TransactionDetailType.CapitalAssetPurchase:

                                //-// detail.CapitalAsset = await GetCapitalAssetAsync(subscriptionId, legacyDetail.CapitalAssetID);

                                break;

                            case TransactionDetailType.CapitalAssetSale:

                                detail.CapitalAssetId = GetNewId(legacyDetail.CapitalAssetID);

                                break;

                        }

                        transaction.Details.Add(detail);

                    }

​

                    var result = await _transactionService.CreateAsync(subscriptionId, fiscalYear.Id, transaction);

                    transactionIds.Add(legacy.TransactionID, result.Id);

​

                    if (!convertHistorical)

                    {

                        // Verify posts

                        decimal debits = 0;

                        decimal credits = 0;

                        foreach (var post in result.Details.SelectMany(x => x.Posts))

                        {

                            var account = await _accountService.GetAsync(subscriptionId, post.AccountId);

                            if ((account.Group.Type.IsDebitAccount() && post.Amount > 0) || (account.Group.Type.IsCreditAccount() && post.Amount < 0))

                            {

                                debits += Math.Abs(post.Amount);

                            }

                            else

                            {

                                credits += Math.Abs(post.Amount);

                            }

                        }

​

                        var legacyPosts = _migration.TransactionDetails.Where(x => x.TransactionID.Equals(legacy.TransactionID));

                        if (!legacyPosts.Where(x => x.Column.Equals("D")).Sum(x => x.Amount).Equals(debits) ||

                            !legacyPosts.Where(x => x.Column.Equals("C")).Sum(x => x.Amount).Equals(credits))

                        {

                            throw new InvalidDataException("Posts do not match.");

                        }

​