public async Task DeleteFromWatchlist(int idwatchlist)
{
UserWatchlist wl = new UserWatchlist
{
Id = idwatchlist
};
_dbContext.UserWatchlist.Attach(wl);
_dbContext.UserWatchlist.Remove(wl);
await _dbContext.SaveChangesAsync();
}
public async Task <CategoryModel> SaveCategory(CategoryDto category)
{
var categoryModel = new CategoryModel
{
name = category.name,
color = category.color
};
context.Add(categoryModel);
await context.SaveChangesAsync();
return(categoryModel);
}
public async Task <IActionResult> UpdateSmartContract([FromBody] ERC20Token model)
{
try
{
_dbContext.Erc20Tokens.Update(model);
await _dbContext.SaveChangesAsync();
return(new OkResult());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private static async Task InsertPageElements(WalletDbContext context)
{
if (context.PageData.Any())
{
return;
}
var data = new List <PageData>()
{
new PageData()
{
ElementName = "AboutPage", ElementData = "Test data for about page"
},
new PageData()
{
ElementName = "ContactPage", ElementData = "Test data for contact page"
},
new PageData()
{
ElementName = "TipsETH", ElementData = "0x53d284357ec70ce289d6d64134dfac8e511c8a3d"
},
new PageData()
{
ElementName = "TipsBTC", ElementData = "0x742d35cc6634c0532925a3b844bc454e4438f44e"
}
};
context.PageData.AddRange(data);
await context.SaveChangesAsync();
}
public async Task <WalletAccount> Handle(DeleteWalletAccountCommand request, CancellationToken cancellationToken)
{
var walletAccountEntity = await _context.WalletAccounts
.FindAsync(request.ID);
if (walletAccountEntity == null)
{
return(new WalletAccount {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
_context.WalletAccounts.Remove(walletAccountEntity);
if (await _context.SaveChangesAsync() > 0)
{
walletAccountEntity.statusCode = SharedStatusCodes.Deleted;
}
else
{
walletAccountEntity.statusCode = SharedStatusCodes.Failed;
}
return(walletAccountEntity);
}
public async Task <Currency> Handle(CreateCurrencyCommand request, CancellationToken cancellationToken)
{
var entity = _context.Currencies.SingleOrDefault(b => b.Code == request.Code);
if (entity != null)
{
entity.statusCode = SharedStatusCodes.Exists;
return(entity);
}
var currencyEntity = new Currency
{
Name = request.Name,
Symbol = request.Symbol,
Code = request.Code,
AddOnRegistration = request.AddOnRegistration
};
_context.Currencies.Add(currencyEntity);
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
currencyEntity.statusCode = SharedStatusCodes.Created;
}
else
{
currencyEntity.statusCode = SharedStatusCodes.Failed;
}
return(currencyEntity);
}
public async Task <List <SavedCard> > Handle(GetUserSavedCardsQuery request, CancellationToken cancellationToken)
{
await _context.SaveChangesAsync();
List <SavedCard> savedCards = new List <SavedCard>();
try
{
if (request.UserID != null)
{
savedCards = _context.SavedCards.Where(x => x.UserID == request.UserID).ToList();
savedCards.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
else
{
savedCards = _context.SavedCards.ToList();
savedCards.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
}
catch (Exception)
{
savedCards = null;
}
return(savedCards);
}
public async Task <PaymentMethod> Handle(CreatePaymentMethodCommand request, CancellationToken cancellationToken)
{
var entity = _context.PaymentMethods.SingleOrDefault(b => b.Name == request.Name);
if (entity != null)
{
entity.statusCode = SharedStatusCodes.Exists;
return(entity);
}
var methodEntity = new PaymentMethod
{
Name = request.Name,
Icon = request.Icon,
ExternalCharges = request.ExternalCharges,
InternalCharges = request.InternalCharges,
AllowDeposit = request.AllowDeposit,
AllowTransfer = request.AllowTransfer,
AllowWithdrawal = request.AllowWithdrawal
};
_context.PaymentMethods.Add(methodEntity);
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
methodEntity.statusCode = SharedStatusCodes.Created;
}
else
{
methodEntity.statusCode = SharedStatusCodes.Failed;
}
return(methodEntity);
}
public async Task <SavedCard> Handle(CreateSavedCardCommand request, CancellationToken cancellationToken)
{
var entity = _context.SavedCards.Where(e => e.MaskedNumber == request.MaskedNumber).FirstOrDefault();
if (entity != null)
{
entity.statusCode = SharedStatusCodes.Exists;
return(entity);
}
var savedCard = new SavedCard
{
UserID = request.UserID,
CardType = request.CardType,
MaskedNumber = request.MaskedNumber,
ExpiryDate = request.ExpiryDate
};
_context.SavedCards.Add(savedCard);
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
savedCard.statusCode = SharedStatusCodes.Created;
}
else
{
savedCard.statusCode = SharedStatusCodes.Failed;
}
return(savedCard);
}
public async Task <PaymentMethod> Handle(DeletePaymentMethodCommand request, CancellationToken cancellationToken)
{
var entity = await _context.PaymentMethods
.FindAsync(request.ID);
if (entity == null)
{
return(new PaymentMethod {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
_context.PaymentMethods.Remove(entity);
if (await _context.SaveChangesAsync() > 0)
{
entity.statusCode = SharedStatusCodes.Deleted;
}
else
{
entity.statusCode = SharedStatusCodes.Failed;
}
return(entity);
}
public async Task <WalletAccount> Handle(CreateWalletAccountCommand request, CancellationToken cancellationToken)
{
var entity = new WalletAccount
{
UserID = request.UserID,
CurrencyID = request.CurrencyID,
WalletAccountCategoryID = request.WalletAccountCategoryID,
WalletAccountCode = WalletAccount.generateWalletAccountCode(request.UserID),
Name = request.Name,
Balance = 0,
IsDefault = false
};
_context.WalletAccounts.Add(entity);
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
entity.statusCode = SharedStatusCodes.Created;
}
else
{
entity.statusCode = SharedStatusCodes.Failed;
}
return(entity);
}
public async Task <List <Recipient> > Handle(GetMultipleRecipientsQuery request, CancellationToken cancellationToken)
{
await _context.SaveChangesAsync();
List <Recipient> recipients = new List <Recipient>();
try
{
if (request.UserID != null)
{
recipients = _context.Recipients.Where(x => x.UserID == request.UserID).ToList();
recipients.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
else
{
recipients = _context.Recipients.ToList();
recipients.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
}
catch (System.Exception)
{
recipients = null;
}
return(recipients);
}
public async Task <SavedCard> Handle(DeleteSavedCardCommand request, CancellationToken cancellationToken)
{
var cardEntity = await _context.SavedCards
.FindAsync(request.ID);
if (cardEntity == null)
{
return(new SavedCard {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
_context.SavedCards.Remove(cardEntity);
if (await _context.SaveChangesAsync() > 0)
{
cardEntity.statusCode = SharedStatusCodes.Deleted;
}
else
{
cardEntity.statusCode = SharedStatusCodes.Failed;
}
return(cardEntity);
}
public async Task Handle(OrderStockUpdatedMessage message)
{
_logger.LogInformation($"OrderStockUpdated message was received. Order Id = {message.OrderId}");
var wallet = await _dbContext.Wallets.FirstOrDefaultAsync(x => x.UserId == message.UserId);
var totalPrice = message.Products.Sum(x => x.Quantity * x.UnitPrice);
if (wallet.Balance >= totalPrice)
{
wallet.Balance -= totalPrice;
await _dbContext.SaveChangesAsync();
await _kafkaMessageProducer.Produce(OrderWalletPayCompletedTopicName, message.OrderId.ToString(),
new { message.OrderId });
_logger.LogInformation($"OrderWalletPayCompleted message was sent. Order Id = {message.OrderId}");
}
else
{
var orderWalletPayErrorMessage = new OrderWalletPayErrorMessage
{
OrderId = message.OrderId,
WalletError = WalletError.InsufficientBalance,
Products = message.Products.Select(x => new ProductDto
{
ProductId = x.ProductId, Quantity = x.Quantity
})
};
await _kafkaMessageProducer.Produce(OrderWalletPayErrorTopicName, message.OrderId.ToString(),
orderWalletPayErrorMessage);
_logger.LogWarning($"OrderWalletPayError message was sent. Order Id = {message.OrderId}");
}
}
public async Task <PaymentMethod> Handle(UpdatePaymentMethodCommand request, CancellationToken cancellationToken)
{
var entity = _context.PaymentMethods.SingleOrDefault(b => b.ID == request.ID);
if (entity == null)
{
return(new PaymentMethod {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
if (entity.Name != request.Name)
{
entity.Name = request.Name;
}
if (entity.Icon != request.Icon)
{
entity.Icon = request.Icon;
}
if (request.ExternalCharges != null)
{
entity.ExternalCharges = request.ExternalCharges;
}
if (request.InternalCharges != null)
{
entity.InternalCharges = request.InternalCharges;
}
if (request.AllowDeposit != null)
{
entity.AllowDeposit = request.AllowDeposit;
}
if (request.AllowTransfer != null)
{
entity.AllowTransfer = request.AllowTransfer;
}
if (request.AllowWithdrawal != null)
{
entity.AllowWithdrawal = request.AllowWithdrawal;
}
if (!_context.Entry(entity).Context.ChangeTracker.HasChanges())
{
entity.statusCode = SharedStatusCodes.Unchanged;
return(entity);
}
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
entity.statusCode = SharedStatusCodes.Updated;
}
else
{
entity.statusCode = SharedStatusCodes.Failed;
}
return(entity);
}
public async Task <IActionResult> Freeze([FromBody] FreezeRequest freezeRequest)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
var account = await _dbContext.Account.FirstOrDefaultAsync(a => a.Id == freezeRequest.Account);
if (account == null)
{
return(StatusCode(205));
}
account.IsFrozen = true;
await _dbContext.SaveChangesAsync();
return(new OkResult());
}
private static async Task InsertTokens(WalletDbContext context)
{
if (context.Erc20Tokens.Any())
{
return;
}
var tokens = ERC20TokensData.GetTokens();
context.Erc20Tokens.AddRange(tokens);
await context.SaveChangesAsync();
}
public async Task <TransactionModel> SaveTransaction(TransactionDto transaction)
{
CategoryModel categoryModel = await context.Category.Where(c => c.id == transaction.categoryId).FirstOrDefaultAsync();
if (categoryModel == null)
{
throw new Exception("Brak kategorii transakcji");
}
var transactionModel = new TransactionModel
{
title = transaction.title,
type = transaction.type,
category = categoryModel,
amount = transaction.amount
};
context.Add(transactionModel);
await context.SaveChangesAsync();
return(transactionModel);
}
public async Task <List <Currency> > Handle(GetMultipleCurrenciesQuery request, CancellationToken cancellationToken)
{
await _context.SaveChangesAsync();
List <Currency> currencies = _context.Currencies.ToList();
if (currencies.Count > 0)
{
currencies.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
return(currencies);
}
public async Task <List <PaymentMethod> > Handle(GetMultiplePaymentMethodsQuery request, CancellationToken cancellationToken)
{
await _context.SaveChangesAsync();
List <PaymentMethod> methods = _context.PaymentMethods.ToList();
if (methods.Count > 0)
{
methods.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved;
}
return(methods);
}
public async Task <Currency> Handle(UpdateCurrencyCommand request, CancellationToken cancellationToken)
{
var currencyEntity = _context.Currencies.SingleOrDefault(b => b.ID == request.ID);
if (currencyEntity == null)
{
return(new Currency {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
if (request.Name != null)
{
currencyEntity.Name = request.Name;
}
if (request.Code != null)
{
currencyEntity.Code = request.Code;
}
if (request.Symbol != null)
{
currencyEntity.Symbol = request.Symbol;
}
if (request.AddOnRegistration != null && request.AddOnRegistration == true)
{
foreach (var crr in _context.Currencies.Where(x => x.AddOnRegistration == true).ToList())
{
crr.AddOnRegistration = false;
}
currencyEntity.AddOnRegistration = request.AddOnRegistration;
}
if (!_context.Entry(currencyEntity).Context.ChangeTracker.HasChanges())
{
currencyEntity.statusCode = SharedStatusCodes.Unchanged;
return(currencyEntity);
}
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
currencyEntity.statusCode = SharedStatusCodes.Updated;
}
else
{
currencyEntity.statusCode = SharedStatusCodes.Failed;
}
return(currencyEntity);
}
public async Task <IActionResult> SetPageElements([FromBody] PageData[] model)
{
try
{
dbContext.PageData.UpdateRange(model);
await dbContext.SaveChangesAsync();
return(new OkResult());
}
catch (Exception e)
{
return(BadRequest($"En error occurred :{e.Message}"));
}
}
public async Task <IActionResult> Register([FromBody] SignUpRequest signUpRequest)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
var user = await _dbContext.User.FirstOrDefaultAsync(u =>
u.Email == signUpRequest.Email || u.Username == signUpRequest.Username);
if (user != null)
{
return(StatusCode(205));
}
var accountId = Guid.NewGuid().ToString();
await _dbContext.Account.AddAsync(new Account
{
Id = accountId,
Balance = 0,
IsFrozen = false
});
await _dbContext.User.AddAsync(new User
{
Username = signUpRequest.Username, Firstname = signUpRequest.Firstname, Middlename = signUpRequest.Middlename,
Lastname = signUpRequest.Lastname,
Email = signUpRequest.Email, Password = signUpRequest.Password, Account = accountId
});
await _dbContext.SaveChangesAsync();
await Authenticate(signUpRequest.Username); // аутентификация
return(new OkResult());
}
public async Task <Recipient> Handle(CreateRecipientCommand request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Email) && string.IsNullOrEmpty(request.Phone))
{
return(new Recipient {
statusCode = RecipientStatusCodes.MissingEmailandPhone
});
}
var user = _context.Users.Where(e => e.ID == request.UserID).FirstOrDefault();
if (user == null)
{
return(new Recipient {
ID = 0, statusCode = SharedStatusCodes.UserNotFound
});
}
var entity = _context.Recipients.Where(e => e.UserID == request.UserID && ((e.Email == request.Email && e.Email != null) || (e.Phone == request.Phone && e.Phone != null))).FirstOrDefault();
if (entity != null)
{
entity.statusCode = SharedStatusCodes.Exists;
return(entity);
}
var recipientEntity = new Recipient
{
UserID = request.UserID,
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Phone = request.Phone
};
_context.Recipients.Add(recipientEntity);
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
recipientEntity.statusCode = SharedStatusCodes.Created;
}
else
{
recipientEntity.statusCode = SharedStatusCodes.Failed;
}
return(recipientEntity);
}
public async Task <Recipient> Handle(UpdateRecipientCommand request, CancellationToken cancellationToken)
{
var recipientEntity = _context.Recipients.SingleOrDefault(b => b.ID == request.ID);
if (recipientEntity == null)
{
return(new Recipient {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
if (recipientEntity.FirstName != request.FirstName)
{
recipientEntity.FirstName = request.FirstName;
}
if (recipientEntity.LastName != request.LastName)
{
recipientEntity.LastName = request.LastName;
}
if (request.Email != null)
{
recipientEntity.Email = request.Email;
}
if (request.Phone != null)
{
recipientEntity.Phone = request.Phone;
}
if (!_context.Entry(recipientEntity).Context.ChangeTracker.HasChanges())
{
recipientEntity.statusCode = SharedStatusCodes.Unchanged;
return(recipientEntity);
}
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
recipientEntity.statusCode = SharedStatusCodes.Updated;
}
else
{
recipientEntity.statusCode = SharedStatusCodes.Failed;
}
return(recipientEntity);
}
public async Task <IActionResult> Add([FromBody] AddRequest request)
{
var account = await _dbContext.Account.FirstOrDefaultAsync(a => a.Id == request.Account);
if (account == null)
{
return(StatusCode(205));
}
if (account.IsFrozen)
{
return(StatusCode(202));
}
account.Balance += request.MoneyAmount * 0.998f;
await _dbContext.SaveChangesAsync();
return(new OkResult());
}
public async Task <Country> Handle(UpdateCountryCommand request, CancellationToken cancellationToken)
{
var entity = _context.Countries.SingleOrDefault(b => b.ID == request.ID);
if (entity == null)
{
return(new Country {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
if (request.DefaultCurrencyID != null)
{
entity.DefaultCurrencyID = request.DefaultCurrencyID;
}
if (request.Name != null)
{
entity.Name = request.Name;
}
if (request.Code != null)
{
entity.Code = request.Code;
}
if (request.PhoneCode != null)
{
entity.PhoneCode = request.PhoneCode;
}
if (!_context.Entry(entity).Context.ChangeTracker.HasChanges())
{
entity.statusCode = SharedStatusCodes.Unchanged;
return(entity);
}
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
entity.statusCode = SharedStatusCodes.Updated;
}
else
{
entity.statusCode = SharedStatusCodes.Failed;
}
return(entity);
}
public async Task <SavedCard> Handle(UpdateSavedCardCommand request, CancellationToken cancellationToken)
{
var cardEntity = _context.SavedCards.SingleOrDefault(b => b.ID == request.ID);
if (cardEntity == null)
{
return(new SavedCard {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
if (cardEntity.MaskedNumber != request.MaskedNumber)
{
cardEntity.MaskedNumber = request.MaskedNumber;
}
if (cardEntity.CardType != request.CardType)
{
cardEntity.CardType = request.CardType;
}
if (cardEntity.ExpiryDate != request.ExpiryDate)
{
cardEntity.ExpiryDate = request.ExpiryDate;
}
if (!_context.Entry(cardEntity).Context.ChangeTracker.HasChanges())
{
cardEntity.statusCode = SharedStatusCodes.Unchanged;
return(cardEntity);
}
if (await _context.SaveChangesAsync(cancellationToken) > 0)
{
cardEntity.statusCode = SharedStatusCodes.Updated;
}
else
{
cardEntity.statusCode = SharedStatusCodes.Failed;
}
return(cardEntity);
}
public async Task <User> Handle(DeleteUserCommand request, CancellationToken cancellationToken)
{
var entity = _context.Users.SingleOrDefault(x => x.ID == request.ID);
if (entity == null)
{
return(new User {
ID = 0, statusCode = SharedStatusCodes.NotFound
});
}
_context.Users.Remove(entity);
// TO DO - remove other entities associated with this user
await _context.SaveChangesAsync(cancellationToken);
return(entity);
}
private static async Task InsertUser(WalletDbContext context, UserManager <User> userManager,
RoleManager <IdentityRole> roleManager)
{
if ((await context.Users.FirstOrDefaultAsync(u => u.Email == "*****@*****.**")) != null)
{
return;
}
const string email = "*****@*****.**";
const string role = "Admin";
await CreateDefaultAdministratorRole(roleManager, role);
var user = await CreateDefaultUser(userManager, email);
await AddDefaultRoleToDefaultUser(userManager, role, user);
user.EmailConfirmed = true;
await context.SaveChangesAsync();
}