private async Task <int> SeedCountriesAsync(CancellationToken cancellationToken)
{
int itemsAdded = 0;
var countries = _fileService.ReadCSVFile <CountryCSV>("Data/Countries.csv");
for (int i = 0; i < countries.Count; i++)
{
Countries.Add((i + 1), new Country {
CountryCode = countries[i].CountryCode, Name = countries[i].Name
});
}
if (!_context.Countries.Any())
{
foreach (var item in Countries.Values)
{
_context.Countries.Add(item);
itemsAdded++;
}
await _context.SaveChangesAsync(cancellationToken);
}
return(itemsAdded);
}
public async Task <UpdateProjectStatusResponse> Handle(UpdateProjectStatusRequest request, CancellationToken cancellationToken)
{
var result = new UpdateProjectStatusResponse();
var project = await _context.Projects
.Where(x => x.ProjectID == request.ProjectID)
.SingleOrDefaultAsync(cancellationToken);
if (project == null)
{
throw new NotFoundException(nameof(Project), request.ProjectID);
}
project.ProjectStatus = request.NewProjectStatus;
await _context.SaveChangesAsync(cancellationToken);
var projectStatusLog = new ProjectStatusLog
{
ProjectID = project.ProjectID,
ProjectStatus = project.ProjectStatus,
Comment = request.Comment
};
await _context.ProjectStatusLogs.AddAsync(projectStatusLog);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
result.ProjectID = project.ProjectID;
result.NewProjectStatus = request.NewProjectStatus;
return(result);
}
public async Task <UpdateProjectDocumentResponse> Handle(UpdateProjectDocumentRequest request, CancellationToken cancellationToken)
{
var result = new UpdateProjectDocumentResponse();
var options = _configuration.GetSection(FortifexOptions.RootSection).Get <FortifexOptions>();
var projectDocument = await _context.ProjectDocuments
.Where(x => x.ProjectDocumentID == request.ProjectDocumentID)
.SingleOrDefaultAsync(cancellationToken);
if (projectDocument != null)
{
result.ProjectID = projectDocument.ProjectID;
projectDocument.Title = request.Title;
if (request.FormFileProjectDocument != null)
{
var processFileResult = await _fileService.ProcessFile(request.FormFileProjectDocument);
if (processFileResult.IsSuccessful)
{
var originalFileName = WebUtility.HtmlEncode(request.FormFileProjectDocument.FileName);
var folderPath = Path.Combine(options.ProjectDocumentsRootFolderPath, projectDocument.ProjectID.ToString());
var trustedFileNameForFileStorage = $"{projectDocument.DocumentID}{Path.GetExtension(originalFileName)}";
var saveDocumentResult = await _fileService.SaveFile(processFileResult.FileContent, folderPath, trustedFileNameForFileStorage);
if (saveDocumentResult.IsSuccessful)
{
projectDocument.OriginalFileName = originalFileName;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
}
else
{
result.ErrorMessage = saveDocumentResult.ErrorMessage;
}
}
else
{
result.ErrorMessage = processFileResult.ErrorMessage;
}
}
else
{
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
}
}
return(result);
}
public async Task <CreateProjectsResponse> Handle(CreateProjectsRequest request, CancellationToken cancellationToken)
{
var result = new CreateProjectsResponse()
{
IsSuccessful = false
};
#region Check if Member already have Project
var member = await _context.Projects
.Where(x => x.MemberUsername == request.MemberUsername)
.FirstOrDefaultAsync(cancellationToken);
if (member != null)
{
result.ProjectID = member.ProjectID;
return(result);
}
#endregion
#region Add New Project
var project = new Project
{
BlockchainID = request.BlockchainID,
MemberUsername = request.MemberUsername,
Name = request.Name,
Description = request.Description,
WalletAddress = request.WalletAddress,
ProjectStatus = ProjectStatus.Draft
};
await _context.Projects.AddAsync(project);
await _context.SaveChangesAsync(cancellationToken);
#endregion
var projectStatusLog = new ProjectStatusLog
{
ProjectID = project.ProjectID,
ProjectStatus = ProjectStatus.Draft,
Comment = "Project has been created"
};
await _context.ProjectStatusLogs.AddAsync(projectStatusLog);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
result.ProjectID = project.ProjectID;
return(result);
}
public async Task <RejectInvitationResponse> Handle(RejectInvitationRequest query, CancellationToken cancellationToken)
{
var result = new RejectInvitationResponse();
var contributor = await _context.Contributors
.Where(x => x.InvitationCode == new Guid(query.InvitationCode))
.SingleOrDefaultAsync();
if (contributor != null)
{
if (contributor.InvitationStatus == InvitationStatus.Invited)
{
contributor.InvitationStatus = InvitationStatus.Rejected;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
}
}
else
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.ProjectNotFound;
}
return(result);
}
public async Task <UpdateContributorInvitationStatusResponse> Handle(UpdateContributorInvitationStatusRequest request, CancellationToken cancellationToken)
{
var result = new UpdateContributorInvitationStatusResponse()
{
IsSuccessful = false
};
var contributor = await _context.Contributors
.Where(x => x.ContributorID == request.ContributorID)
.SingleOrDefaultAsync(cancellationToken);
if (contributor == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.ContributorNotFound;
return(result);
}
contributor.InvitationStatus = request.InvitationStatus;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateSyncResponse> Handle(UpdateSyncRequest request, CancellationToken cancellationToken)
{
var result = new UpdateSyncResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(y => y.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
throw new NotFoundException(nameof(Transaction), request.TransactionID);
}
transaction.UnitPriceInUSD = request.UnitPriceInUSD;
if (transaction.TransactionType == TransactionType.SyncTransactionIN || transaction.TransactionType == TransactionType.SyncTransactionOUT)
{
transaction.PairWalletName = request.PairWalletName;
}
await _context.SaveChangesAsync(cancellationToken);
result.WalletID = transaction.Pocket.WalletID;
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateDepositResponse> Handle(UpdateDepositRequest request, CancellationToken cancellationToken)
{
var result = new UpdateDepositResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(a => a.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.TransactionNotFound;
return(result);
}
transaction.Amount = request.Amount;
transaction.TransactionDateTime = request.TransactionDateTime;
transaction.LastModified = _dateTimeOffset.Now;
await _context.SaveChangesAsync(cancellationToken);
result.WalletID = transaction.Pocket.WalletID;
result.IsSuccessful = true;
return(result);
}
public async Task <DeleteOwnerResponse> Handle(DeleteOwnerRequest request, CancellationToken cancellationToken)
{
var result = new DeleteOwnerResponse();
var owner = await _context.Owners
.Where(x => x.OwnerID == request.OwnerID)
.Include(a => a.Wallets)
.ThenInclude(b => b.Pockets)
.ThenInclude(c => c.Transactions)
.ThenInclude(d => d.FromInternalTransfers)
.ThenInclude(d => d.ToTransaction)
.Include(a => a.Wallets)
.ThenInclude(b => b.Pockets)
.ThenInclude(c => c.Transactions)
.ThenInclude(d => d.ToInternalTransfers)
.ThenInclude(d => d.FromTransaction)
.Include(a => a.Wallets)
.ThenInclude(b => b.Pockets)
.ThenInclude(c => c.Transactions)
.ThenInclude(d => d.FromTrades)
.Include(a => a.Wallets)
.ThenInclude(b => b.Pockets)
.ThenInclude(c => c.Transactions)
.ThenInclude(d => d.ToTrades)
.SingleOrDefaultAsync();
if (owner == null)
{
result.IsSuccessful = false;
}
result.ErrorMessage = ErrorMessage.OwnerNotFound;
foreach (var wallet in owner.Wallets)
{
foreach (var pocket in wallet.Pockets)
{
foreach (var transaction in pocket.Transactions)
{
_context.InternalTransfers.RemoveRange(transaction.FromInternalTransfers);
_context.Transactions.RemoveRange(transaction.FromInternalTransfers.Select(x => x.ToTransaction));
_context.InternalTransfers.RemoveRange(transaction.ToInternalTransfers);
_context.Transactions.RemoveRange(transaction.ToInternalTransfers.Select(x => x.FromTransaction));
_context.Trades.RemoveRange(transaction.FromTrades);
_context.Trades.RemoveRange(transaction.ToTrades);
}
_context.Transactions.RemoveRange(pocket.Transactions);
}
_context.Pockets.RemoveRange(wallet.Pockets);
}
_context.Wallets.RemoveRange(owner.Wallets);
_context.Owners.Remove(owner);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <CreateWithdrawalResponse> Handle(CreateWithdrawalRequest request, CancellationToken cancellationToken)
{
var result = new CreateWithdrawalResponse();
Wallet walletForWithdrawal = await _context.Wallets
.Where(x => x.WalletID == request.WalletID)
.Include(x => x.Pockets)
.SingleOrDefaultAsync(cancellationToken);
if (walletForWithdrawal == null)
{
throw new NotFoundException(nameof(Wallet), request.WalletID);
}
Pocket pocketForWithdrawal = walletForWithdrawal.Pockets.Single(x => x.IsMain);
Transaction transactionForWithdrawal = new Transaction
{
PocketID = pocketForWithdrawal.PocketID,
Amount = -request.Amount,
TransactionHash = string.Empty,
TransactionType = TransactionType.Withdrawal,
TransactionDateTime = request.TransactionDateTime
};
_context.Transactions.Add(transactionForWithdrawal);
await _context.SaveChangesAsync(cancellationToken);
result.TransactionID = transactionForWithdrawal.TransactionID;
result.WalletID = walletForWithdrawal.WalletID;
return(result);
}
public async Task <DeleteDepositResponse> Handle(DeleteDepositRequest request, CancellationToken cancellationToken)
{
var result = new DeleteDepositResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(y => y.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.TransactionNotFound;
return(result);
}
result.WalletID = transaction.Pocket.WalletID;
_context.Transactions.Remove(transaction);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateWithdrawalResponse> Handle(UpdateWithdrawalRequest request, CancellationToken cancellationToken)
{
var result = new UpdateWithdrawalResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(y => y.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
throw new NotFoundException(nameof(Transaction), request.TransactionID);
}
result.WalletID = transaction.Pocket.WalletID;
transaction.Amount = -request.Amount;
transaction.TransactionDateTime = request.TransactionDateTime;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateFiatCurrencyNamesResponse> Handle(UpdateFiatCurrencyNamesRequest request, CancellationToken cancellationToken)
{
var result = new UpdateFiatCurrencyNamesResponse();
var fiatCurrencyCollection = await _fiatService.GetFiatCurrencyCollectionAsync();
foreach (var fiatCurrency in fiatCurrencyCollection.Currencies)
{
var existingFiatCurrency = await _context.Currencies
.Where(x => x.Symbol == fiatCurrency.Symbol && x.CurrencyType == CurrencyType.Fiat)
.SingleOrDefaultAsync(cancellationToken);
if (existingFiatCurrency != null)
{
existingFiatCurrency.Name = fiatCurrency.Name;
result.Currencies.Add(new CurrencyDTO
{
CurrencyID = existingFiatCurrency.CurrencyID,
Symbol = existingFiatCurrency.Symbol,
Name = existingFiatCurrency.Name
});
}
}
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateStartingBalanceResponse> Handle(UpdateStartingBalanceRequest request, CancellationToken cancellationToken)
{
var result = new UpdateStartingBalanceResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(y => y.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
throw new NotFoundException(nameof(Transaction), request.TransactionID);
}
transaction.Amount = request.Amount;
transaction.UnitPriceInUSD = request.UnitPriceInUSD;
transaction.LastModified = _dateTimeOffset.Now;
await _context.SaveChangesAsync(cancellationToken);
result.WalletID = transaction.Pocket.WalletID;
result.IsSuccessful = true;
return(result);
}
public async Task <UpdatePreferredFiatCurrencyResponse> Handle(UpdatePreferredFiatCurrencyRequest request, CancellationToken cancellationToken)
{
var member = await _context.Members
.Where(x => x.MemberUsername == request.MemberUsername)
.SingleOrDefaultAsync(cancellationToken);
if (member == null)
{
throw new NotFoundException(nameof(Member), request.MemberUsername);
}
var currency = await _context.Currencies
.Where(x => x.CurrencyID == request.PreferredFiatCurrencyID)
.SingleOrDefaultAsync(cancellationToken);
if (currency == null)
{
throw new NotFoundException(nameof(Currency), request.PreferredFiatCurrencyID);
}
if (currency.CurrencyType != CurrencyType.Fiat)
{
throw new ArgumentException($"[{nameof(Currency)}] with key [{request.PreferredFiatCurrencyID}] is not a Fiat Currency");
}
member.PreferredFiatCurrencyID = request.PreferredFiatCurrencyID;
await _context.SaveChangesAsync(cancellationToken);
return(new UpdatePreferredFiatCurrencyResponse
{
IsSuccessful = true
});
}
public async Task <UpdatePersonalWalletResponse> Handle(UpdatePersonalWalletRequest request, CancellationToken cancellationToken)
{
var wallet = await _context.Wallets.FindAsync(request.WalletID);
if (wallet == null)
{
throw new NotFoundException(nameof(Wallet), request.WalletID);
}
wallet.Name = request.Name;
// Property lain selain Name hanya bisa diubah kalau Wallet tidak synchronized
if (!wallet.IsSynchronized)
{
wallet.Address = request.Address;
var mainPocket = await _context.Pockets
.Where(x => x.WalletID == wallet.WalletID && x.IsMain)
.Include(a => a.Transactions)
.SingleOrDefaultAsync(cancellationToken);
mainPocket.Address = request.Address;
// Kalau wallet ini mau ganti Blockchain
if (wallet.BlockchainID != request.BlockchainID)
{
bool hasInternalTransfers = mainPocket.Transactions.Any(x =>
x.TransactionType == TransactionType.InternalTransferIN ||
x.TransactionType == TransactionType.InternalTransferOUT);
// Boleh ganti Blockchain hanya jika belum pernah ada transaksi Internal Transfer
if (!hasInternalTransfers)
{
wallet.BlockchainID = request.BlockchainID;
var currency = await _context.Currencies
.Where(x =>
x.BlockchainID == request.BlockchainID &&
x.CurrencyType == CurrencyType.Coin)
.SingleOrDefaultAsync(cancellationToken);
mainPocket.CurrencyID = currency.CurrencyID;
}
}
}
await _context.SaveChangesAsync(cancellationToken);
return(new UpdatePersonalWalletResponse
{
IsSuccessful = true
});
}
public async Task <DeleteInternalTransferResponse> Handle(DeleteInternalTransferRequest request, CancellationToken cancellationToken)
{
var result = new DeleteInternalTransferResponse
{
IsSuccessful = false
};
var internalTransfers = await _context.InternalTransfers
.Where(x => x.InternalTransferID == request.InternalTransfersID)
.SingleOrDefaultAsync();
if (internalTransfers == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.InternalTransferNotFound;
return(result);
}
_context.InternalTransfers.Remove(internalTransfers);
await _context.SaveChangesAsync(cancellationToken);
var fromTransaction = await _context.Transactions
.Where(x => x.TransactionID == internalTransfers.FromTransactionID)
.SingleOrDefaultAsync();
_context.Transactions.Remove(fromTransaction);
await _context.SaveChangesAsync(cancellationToken);
var toTransaction = await _context.Transactions
.Where(x => x.TransactionID == internalTransfers.ToTransactionID)
.SingleOrDefaultAsync();
_context.Transactions.Remove(toTransaction);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <DeleteTradeResponse> Handle(DeleteTradeRequest request, CancellationToken cancellationToken)
{
var result = new DeleteTradeResponse
{
IsSuccessful = false
};
var trade = await _context.Trades
.Where(x => x.TradeID == request.TradeID)
.SingleOrDefaultAsync();
if (trade == null)
{
throw new NotFoundException(nameof(Trade), request.TradeID);
}
// Delete Trade
_context.Trades.Remove(trade);
await _context.SaveChangesAsync(cancellationToken);
// Delete source Transactions
var sourceTransaction = await _context.Transactions
.Where(x => x.TransactionID == trade.FromTransactionID)
.SingleOrDefaultAsync();
_context.Transactions.Remove(sourceTransaction);
await _context.SaveChangesAsync(cancellationToken);
// Delete destination Transactions
var destinationTransaction = await _context.Transactions
.Where(x => x.TransactionID == trade.ToTransactionID)
.SingleOrDefaultAsync();
_context.Transactions.Remove(destinationTransaction);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <DeleteWalletResponse> Handle(DeleteWalletRequest request, CancellationToken cancellationToken)
{
var wallet = await _context.Wallets
.Where(x => x.WalletID == request.WalletID)
.Include(a => a.Pockets)
.ThenInclude(b => b.Transactions)
.ThenInclude(c => c.FromInternalTransfers)
.ThenInclude(d => d.ToTransaction)
.Include(a => a.Pockets)
.ThenInclude(b => b.Transactions)
.ThenInclude(c => c.ToInternalTransfers)
.ThenInclude(d => d.FromTransaction)
.Include(a => a.Pockets)
.ThenInclude(b => b.Transactions)
.ThenInclude(c => c.FromTrades)
.ThenInclude(d => d.ToTransaction)
.Include(a => a.Pockets)
.ThenInclude(b => b.Transactions)
.ThenInclude(c => c.ToTrades)
.ThenInclude(d => d.FromTransaction)
.SingleOrDefaultAsync();
if (wallet == null)
{
throw new NotFoundException(nameof(Wallet), request.WalletID);
}
//Deleting Transactions
foreach (var pocket in wallet.Pockets)
{
foreach (var transaction in pocket.Transactions)
{
_context.InternalTransfers.RemoveRange(transaction.FromInternalTransfers);
_context.Transactions.RemoveRange(transaction.FromInternalTransfers.Select(x => x.ToTransaction));
_context.InternalTransfers.RemoveRange(transaction.ToInternalTransfers);
_context.Transactions.RemoveRange(transaction.ToInternalTransfers.Select(x => x.FromTransaction));
_context.Trades.RemoveRange(transaction.FromTrades);
_context.Trades.RemoveRange(transaction.ToTrades);
}
_context.Transactions.RemoveRange(pocket.Transactions);
}
_context.Pockets.RemoveRange(wallet.Pockets);
_context.Wallets.Remove(wallet);
await _context.SaveChangesAsync(cancellationToken);
return(new DeleteWalletResponse
{
IsSuccessful = true
});
}
public async Task <CreateExternalTransferResponse> Handle(CreateExternalTransferRequest request, CancellationToken cancellationToken)
{
var result = new CreateExternalTransferResponse();
Wallet wallet = await _context.Wallets
.Where(x => x.WalletID == request.WalletID)
.Include(x => x.Pockets)
.SingleOrDefaultAsync(cancellationToken);
if (wallet == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.WalletNotFound;
return(result);
}
Pocket mainPocket = wallet.Pockets.Single(x => x.IsMain);
decimal amount = request.Amount;
TransactionType transactionType = TransactionType.ExternalTransferIN;
if (request.TransferDirection == TransferDirection.OUT)
{
amount = -request.Amount;
transactionType = TransactionType.ExternalTransferOUT;
}
Transaction transactionForExternalTransfer = new Transaction
{
PocketID = mainPocket.PocketID,
Amount = amount,
UnitPriceInUSD = request.UnitPriceInUSD,
TransactionHash = string.Empty,
PairWalletName = string.IsNullOrEmpty(request.PairWalletName) ? "External Wallet" : request.PairWalletName,
PairWalletAddress = string.IsNullOrEmpty(request.PairWalletAddress) ? "External Wallet Address" : request.PairWalletAddress,
TransactionType = transactionType,
TransactionDateTime = request.TransactionDateTime,
Created = _dateTimeOffset.Now,
LastModified = _dateTimeOffset.Now
};
_context.Transactions.Add(transactionForExternalTransfer);
await _context.SaveChangesAsync(cancellationToken);
result.TransactionID = transactionForExternalTransfer.TransactionID;
result.IsSuccessful = true;
return(result);
}
public async Task <SeedFiatCurrenciesResponse> Handle(SeedFiatCurrenciesRequest request, CancellationToken cancellationToken)
{
var result = new SeedFiatCurrenciesResponse();
var fiatCurrencyMapJSON = _fileService.ReadJSONFile <FiatCurrencyMapJSON>(FilePath.FiatCurrencyMapJSON);
if (fiatCurrencyMapJSON.status.error_code == 0)
{
Blockchain fiatBlockchain = new Blockchain
{
BlockchainID = BlockchainID.Fiat,
Symbol = BlockchainSymbol.Fiat,
Name = BlockchainName.Fiat
};
foreach (var fiatCurrencyJSON in fiatCurrencyMapJSON.data)
{
fiatBlockchain.Currencies.Add(new Currency
{
BlockchainID = fiatBlockchain.BlockchainID,
Symbol = fiatCurrencyJSON.symbol,
Name = fiatCurrencyJSON.name,
CoinMarketCapID = fiatCurrencyJSON.id,
Rank = 0,
CurrencyType = CurrencyType.Fiat,
IsShownInTradePair = fiatCurrencyJSON.symbol == CurrencySymbol.USD,
IsForPreferredOption = true
});
}
if (!_context.Blockchains.Any(x => x.BlockchainID == BlockchainID.Fiat))
{
_context.Blockchains.Add(fiatBlockchain);
await _context.SaveChangesAsync(cancellationToken);
result.FiatCurrenciesAdded = fiatBlockchain.Currencies.Count;
}
result.IsSuccessful = true;
}
else
{
result.IsSuccessful = false;
result.ErrorMessage = fiatCurrencyMapJSON.status.error_message;
}
return(result);
}
public async Task <UpdateExternalTransferResponse> Handle(UpdateExternalTransferRequest request, CancellationToken cancellationToken)
{
var result = new UpdateExternalTransferResponse();
var transaction = await _context.Transactions
.Where(x => x.TransactionID == request.TransactionID)
.Include(y => y.Pocket)
.SingleOrDefaultAsync(cancellationToken);
if (transaction == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.TransactionNotFound;
return(result);
}
TransactionType transactionType = TransactionType.ExternalTransferIN;
decimal amount = request.Amount;
if (request.TransferDirection == TransferDirection.OUT)
{
transactionType = TransactionType.ExternalTransferOUT;
if (amount > 0)
{
amount = -request.Amount;
}
}
transaction.PairWalletName = string.IsNullOrEmpty(request.PairWalletName) ? "External Wallet" : request.PairWalletName;
transaction.PairWalletAddress = string.IsNullOrEmpty(request.PairWalletAddress) ? "External Wallet Address" : request.PairWalletAddress;
transaction.TransactionType = transactionType;
transaction.Amount = amount;
transaction.UnitPriceInUSD = request.UnitPriceInUSD;
transaction.TransactionDateTime = request.TransactionDateTime;
transaction.LastModified = _dateTimeOffset.Now;
await _context.SaveChangesAsync(cancellationToken);
result.WalletID = transaction.Pocket.WalletID;
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateTradeResponse> Handle(UpdateTradeRequest request, CancellationToken cancellationToken)
{
var result = new UpdateTradeResponse
{
IsSuccessful = false
};
var trade = await _context.Trades
.Where(x => x.TradeID == request.TradeID)
.Include(a => a.FromTransaction)
.Include(a => a.ToTransaction)
.SingleOrDefaultAsync(cancellationToken);
if (trade == null)
{
throw new NotFoundException(nameof(Trade), request.TradeID);
}
decimal unitPrice = decimal.Round(request.UnitPrice, 4);
decimal totalPrice = request.Amount * unitPrice;
trade.UnitPrice = unitPrice;
trade.FromTransaction.TransactionDateTime = request.TransactionDateTime;
trade.FromTransaction.UnitPriceInUSD = request.UnitPriceInUSD;
trade.ToTransaction.TransactionDateTime = request.TransactionDateTime;
trade.ToTransaction.UnitPriceInUSD = request.UnitPriceInUSD;
if (request.TradeType == TradeType.Buy)
{
trade.FromTransaction.Amount = request.Amount;
trade.ToTransaction.Amount = trade.IsWithholding ? -totalPrice : 0m;
}
else if (request.TradeType == TradeType.Sell)
{
trade.FromTransaction.Amount = -request.Amount;
trade.ToTransaction.Amount = trade.IsWithholding ? totalPrice : 0m;
}
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <ActivateMemberResponse> Handle(ActivateMemberRequest query, CancellationToken cancellationToken)
{
var result = new ActivateMemberResponse();
var member = await _context.Members
.Where(x => x.ActivationCode == query.ActivationCode)
.SingleOrDefaultAsync(cancellationToken);
if (member != null)
{
member.ActivationStatus = ActivationStatus.Active;
await _context.SaveChangesAsync(cancellationToken);
result.MemberUsername = member.MemberUsername;
}
return(result);
}
public async Task <UpdatePreferredTimeFrameResponse> Handle(UpdatePreferredTimeFrameRequest request, CancellationToken cancellationToken)
{
var member = await _context.Members
.Where(x => x.MemberUsername == request.MemberUsername)
.SingleOrDefaultAsync(cancellationToken);
if (member == null)
{
throw new NotFoundException(nameof(Member), request.MemberUsername);
}
member.PreferredTimeFrameID = request.PreferredTimeFrameID;
await _context.SaveChangesAsync(cancellationToken);
return(new UpdatePreferredTimeFrameResponse
{
IsSuccessful = true
});
}
public async Task <UpdateInternalTransferResponse> Handle(UpdateInternalTransferRequest request, CancellationToken cancellationToken)
{
var result = new UpdateInternalTransferResponse
{
IsSuccessful = false
};
var internalTransfer = await _context.InternalTransfers
.Where(x => x.InternalTransferID == request.InternalTransferID)
.SingleOrDefaultAsync(cancellationToken);
if (internalTransfer == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.InternalTransferNotFound;
return(result);
}
decimal amount = request.Amount;
var fromTransaction = await _context.Transactions
.Where(x => x.TransactionID == internalTransfer.FromTransactionID)
.SingleOrDefaultAsync(cancellationToken);
fromTransaction.Amount = -amount;
fromTransaction.TransactionDateTime = request.TransactionDateTime;
var toTransaction = await _context.Transactions
.Where(x => x.TransactionID == internalTransfer.ToTransactionID)
.SingleOrDefaultAsync(cancellationToken);
toTransaction.Amount = amount;
toTransaction.TransactionDateTime = request.TransactionDateTime;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <RemoveAllTransactionsResponse> Handle(RemoveAllTransactionsRequest request, CancellationToken cancellationToken)
{
int transactionsRemoved = await _context.Transactions.CountAsync(cancellationToken);
//var wallets = await _context.Wallets
// .Include(a => a.Pockets)
// .ThenInclude(b => b.Transactions)
// .ThenInclude(c => c.FromInternalTransfers)
// .Include(a => a.Pockets)
// .ThenInclude(b => b.Transactions)
// .ThenInclude(c => c.FromTrades)
// .ToListAsync(cancellationToken);
//foreach (var wallet in wallets)
//{
// foreach (var pocket in wallet.Pockets)
// {
// foreach (var transaction in pocket.Transactions)
// {
// _context.InternalTransfers.RemoveRange(transaction.FromInternalTransfers);
// _context.Trades.RemoveRange(transaction.FromTrades);
// _context.Trades.RemoveRange(transaction.ToTrades);
// }
// transactionsRemoved += pocket.Transactions.Count;
// _context.Transactions.RemoveRange(pocket.Transactions);
// }
//}
_context.InternalTransfers.RemoveRange(_context.InternalTransfers);
_context.Trades.RemoveRange(_context.Trades);
_context.Transactions.RemoveRange(_context.Transactions);
await _context.SaveChangesAsync(cancellationToken);
return(new RemoveAllTransactionsResponse
{
IsSuccessful = true,
TransactionsRemoved = transactionsRemoved
});
}
public async Task <UpdateExchangeOwnerResponse> Handle(UpdateExchangeOwnerRequest request, CancellationToken cancellationToken)
{
var result = new UpdateExchangeOwnerResponse();
var owner = await _context.Owners
.Where(x => x.OwnerID == request.OwnerID)
.SingleOrDefaultAsync(cancellationToken);
if (owner == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.OwnerNotFound;
}
owner.ProviderID = request.ProviderID;
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
public async Task <UpdateFiatCurrencyCoinMarketCapIDsResponse> Handle(UpdateFiatCurrencyCoinMarketCapIDsRequest request, CancellationToken cancellationToken)
{
var result = new UpdateFiatCurrencyCoinMarketCapIDsResponse();
var fiatCurrencyMapJSON = _fileService.ReadJSONFile <FiatCurrencyMapJSON>(FilePath.FiatCurrencyMapJSON);
if (fiatCurrencyMapJSON.status.error_code == 0)
{
foreach (var fiatCurrencyJSON in fiatCurrencyMapJSON.data)
{
string symbol = !string.IsNullOrEmpty(fiatCurrencyJSON.symbol) ? fiatCurrencyJSON.symbol : fiatCurrencyJSON.code;
var currency = await _context.Currencies
.Where(x =>
x.CurrencyType == CurrencyType.Fiat &&
x.Symbol == symbol)
.SingleOrDefaultAsync(cancellationToken);
if (currency != null)
{
currency.CoinMarketCapID = fiatCurrencyJSON.id;
await _context.SaveChangesAsync(cancellationToken);
result.Currencies.Add(new CurrencyDTO
{
CurrencyID = currency.CurrencyID,
Symbol = symbol,
CoinMarketCapID = fiatCurrencyJSON.id
});
}
}
}
result.IsSuccessful = true;
return(result);
}
public async Task <DeleteContributorResponse> Handle(DeleteContributorRequest request, CancellationToken cancellationToken)
{
var result = new DeleteContributorResponse();
var contributor = await _context.Contributors
.Where(x => x.ContributorID == request.ContributorID)
.SingleOrDefaultAsync();
if (contributor == null)
{
result.IsSuccessful = false;
result.ErrorMessage = ErrorMessage.ContributorNotFound;
return(result);
}
_context.Contributors.Remove(contributor);
await _context.SaveChangesAsync(cancellationToken);
result.IsSuccessful = true;
return(result);
}
