private async Task <StatusEnum> SendData <T>(long jobId, List <T> list)
        {
            var transactionCount = 0;
            var blockCount       = 0;

            try
            {
                var jobTimeline = _entity.JobTimeline.Find(jobId);
                var toAdapter   = jobTimeline.Schedule.JobDefinition.Adapter1;

                switch ((AdapterTypeItemEnum)toAdapter.AdapterTypeItemId)
                {
                case AdapterTypeItemEnum.MSSQL:
                case AdapterTypeItemEnum.MySQL:
                case AdapterTypeItemEnum.Oracle:
                    if (typeof(T) == typeof(EthereumBlockModel) || typeof(T) == typeof(BitcoinBlockModel) || typeof(T) == typeof(NeoBlockModel) || typeof(T) == typeof(LitecoinBlockModel))
                    {
                        var result = _dbAdapterService.SendToRelationalDb(jobId, list);

                        if (result.Status != StatusEnum.Success)
                        {
                            return(StatusEnum.Error);
                        }

                        blockCount = list.Count();

                        if (typeof(T) == typeof(EthereumBlockModel))
                        {
                            var model = (List <EthereumBlockModel>)Convert.ChangeType(list, typeof(List <EthereumBlockModel>));
                            transactionCount = model.Select(m => m.BlockTransactions.Count).Sum();
                        }
                        else if (typeof(T) == typeof(BitcoinBlockModel))
                        {
                            var model = (List <BitcoinBlockModel>)Convert.ChangeType(list, typeof(List <BitcoinBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                        else if (typeof(T) == typeof(NeoBlockModel))
                        {
                            var model = (List <NeoBlockModel>)Convert.ChangeType(list, typeof(List <NeoBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                        else if (typeof(T) == typeof(LitecoinBlockModel))
                        {
                            var model = (List <LitecoinBlockModel>)Convert.ChangeType(list, typeof(List <LitecoinBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                    }

                    break;

                case AdapterTypeItemEnum.MongoDB:

                    if (typeof(T) == typeof(EthereumBlockModel) || typeof(T) == typeof(BitcoinBlockModel) || typeof(T) == typeof(NeoBlockModel) || typeof(T) == typeof(LitecoinBlockModel))
                    {
                        var result = _dbAdapterService.SendToMongoDb(toAdapter.EnterpriseAdapter.FirstOrDefault().Id, list);

                        if (result.Status != StatusEnum.Success)
                        {
                            return(StatusEnum.Error);
                        }

                        blockCount = list.Count();

                        if (typeof(T) == typeof(EthereumBlockModel))
                        {
                            var model = (List <EthereumBlockModel>)Convert.ChangeType(list, typeof(List <EthereumBlockModel>));
                            transactionCount = model.Select(m => m.BlockTransactions.Count).Sum();
                        }
                        else if (typeof(T) == typeof(BitcoinBlockModel))
                        {
                            var model = (List <BitcoinBlockModel>)Convert.ChangeType(list, typeof(List <BitcoinBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                        else if (typeof(T) == typeof(NeoBlockModel))
                        {
                            var model = (List <NeoBlockModel>)Convert.ChangeType(list, typeof(List <NeoBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                        else if (typeof(T) == typeof(LitecoinBlockModel))
                        {
                            var model = (List <LitecoinBlockModel>)Convert.ChangeType(list, typeof(List <LitecoinBlockModel>));
                            transactionCount = model.Select(m => m.TransactionList.Count).Sum();
                        }
                    }

                    break;

                case AdapterTypeItemEnum.Ethereum:
                    if (typeof(T) == typeof(BlockchainDataModel))
                    {
                        var model = (BlockchainDataModel)Convert.ChangeType(list[0], typeof(BlockchainDataModel));

                        var blockchainTransactions = await _blockchainService.SendToBlockchain(model);

                        if (blockchainTransactions.Status == StatusEnum.Error)
                        {
                            return(StatusEnum.Error);
                        }

                        if (blockchainTransactions.Value.Count > 0)
                        {
                            _transactionService.UpdateTransactions(blockchainTransactions.Value);
                            transactionCount = blockchainTransactions.Value.Count;
                        }
                    }
                    break;

                case AdapterTypeItemEnum.Cardano:
                case AdapterTypeItemEnum.EOS:
                case AdapterTypeItemEnum.NEO:
                case AdapterTypeItemEnum.Bitcoin:
                    break;

                case AdapterTypeItemEnum.Excel:
                    if (typeof(T) == typeof(EthereumBlockModel))
                    {
                        var model = (List <EthereumBlockModel>)Convert.ChangeType(list, typeof(List <EthereumBlockModel>));

                        var numberOfTransactions = model.SelectMany(b => b.BlockTransactions).Count();

                        if (numberOfTransactions > 0)
                        {
                            var result = _businessAdapterService.CreateXlsxFile(model, jobId);

                            if (result.Status != StatusEnum.Success)
                            {
                                return(StatusEnum.Error);
                            }

                            blockCount       = model.Count();
                            transactionCount = numberOfTransactions;
                        }
                        else
                        {
                            blockCount = model.Count();
                        }
                    }
                    else if (typeof(T) == typeof(BitcoinBlockModel))
                    {
                        var model = (List <BitcoinBlockModel>)Convert.ChangeType(list, typeof(List <BitcoinBlockModel>));

                        var numberOfTransactions = model.SelectMany(b => b.TransactionList).Count();

                        if (numberOfTransactions > 0)
                        {
                            var result = _businessAdapterService.CreateXlsxFile(model, jobId);

                            if (result.Status != StatusEnum.Success)
                            {
                                return(StatusEnum.Error);
                            }

                            blockCount       = model.Count();
                            transactionCount = numberOfTransactions;
                        }
                        else
                        {
                            blockCount = model.Count();
                        }
                    }
                    else if (typeof(T) == typeof(NeoBlockModel))
                    {
                        var model = (List <NeoBlockModel>)Convert.ChangeType(list, typeof(List <NeoBlockModel>));

                        var numberOfTransactions = model.SelectMany(b => b.TransactionList).Count();

                        if (numberOfTransactions > 0)
                        {
                            var result = _businessAdapterService.CreateXlsxFile(model, jobId);

                            if (result.Status != StatusEnum.Success)
                            {
                                return(StatusEnum.Error);
                            }

                            blockCount       = model.Count();
                            transactionCount = numberOfTransactions;
                        }
                        else
                        {
                            blockCount = model.Count();
                        }
                    }
                    else if (typeof(T) == typeof(LitecoinBlockModel))
                    {
                        var model = (List <LitecoinBlockModel>)Convert.ChangeType(list, typeof(List <LitecoinBlockModel>));

                        var numberOfTransactions = model.SelectMany(b => b.TransactionList).Count();

                        if (numberOfTransactions > 0)
                        {
                            var result = _businessAdapterService.CreateXlsxFile(model, jobId);
                            if (result.Status != StatusEnum.Success)
                            {
                                return(StatusEnum.Error);
                            }

                            blockCount       = model.Count();
                            transactionCount = numberOfTransactions;
                        }
                        else
                        {
                            blockCount = model.Count();
                        }
                    }
                    break;

                case AdapterTypeItemEnum.MATLAB:
                    if (typeof(T) == typeof(EthereumBlockModel))
                    {
                        var model = (List <EthereumBlockModel>)Convert.ChangeType(list, typeof(List <EthereumBlockModel>));

                        var numberOfTransactions = model.SelectMany(b => b.BlockTransactions).Count();

                        if (numberOfTransactions > 0)
                        {
                            var result = _businessAdapterService.CreateCsvFile(model, jobId);

                            if (result.Status != StatusEnum.Success)
                            {
                                return(StatusEnum.Error);
                            }

                            blockCount       = model.Count();
                            transactionCount = numberOfTransactions;
                        }
                        else
                        {
                            blockCount = model.Count();
                        }
                    }
                    break;

                default:
                    return(StatusEnum.Error);
                }

                _jobHistoryService.ChangeJobStatus(JobStatus.Done, jobId, transactionCount, blockCount);
                _jobTimelineService.WriteNumberOfTransactions(jobId, transactionCount);
                return(StatusEnum.Success);
            }
            catch (Exception ex)
            {
                _logger.Information($"JobService.SendData(jobId: {jobId}, list: {list})");
                _logger.Error(ex.Message);
                return(StatusEnum.Error);
            }
        }