public ActionResult ClaimLicenses(string key)
{
var transactionId = Common.Utils.SafeConvert.ToGuid(key.DecryptUrl());
using (var context = dataContextFactory.CreateByTransaction(transactionId))
{
var transaction = (from x in context.Transactions where x.TransactionId == transactionId select x)
.Include(x => x.IgnoredItems)
.Include(x => x.TransactionItems.Select(s => s.Sku))
.Include(x => x.TransactionItems.Select(s => s.License))
.FirstOrDefault();
if (transaction == null)
{
throw new EntityNotFoundException("Transaction could not be resolved!");
}
if (transaction.Status == TransactionStatus.Complete)
{
throw new EntityOperationNotSupportedException("Transaction is already claimed!");
}
var viewModel = new TransactionDetailsViewModel(transaction);
return(View(viewModel));
}
}
public async void DeleteCurrentTransaction(TransactionDetailsViewModel wd)
{
try
{
IsWalletPanelEnabled = false;
_currentWallet.DeleteTransaction(wd.Transaction);
await _serviceWallet.UpdateWallet(_currentWallet.Guid.ToString(), _currentWallet.Name, _currentWallet.Balance, _currentWallet.Currency, _currentWallet.Owner, _currentWallet.Description, _currentWallet.Transactions);
await _serviceTransaction.DeleteTransactionAsync(_currentTransaction.TransactionGuid());
Transactions.Remove(wd);
RaisePropertyChanged(nameof(CurrentTransaction));
RaisePropertyChanged(nameof(Transactions));
RaisePropertyChanged(nameof(CurrentWallet));
RaisePropertyChanged(nameof(Wallets));
}
catch (Exception ex)
{
MessageBox.Show($"Transaction delete was failed: {ex.Message}");
return;
}
finally
{
IsWalletPanelEnabled = true;
}
MessageBox.Show($"Transaction was deleted successfully!");
}
public TransactionDetailsView(Transaction transaction)
{
ViewModel = new TransactionDetailsViewModel(transaction);
DataContext = ViewModel;
InitializeComponent();
sender_button.Content = (transaction.Payee != null)?transaction.Payee.Name:transaction.PayeeLabel;
}
// GET: Accounts/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Account account = db.Accounts.Find(id);
if (account == null)
{
return(HttpNotFound());
}
var transactions = new List <Transaction>();
var trans = db.Transactions.Where(a => a.AccountId == id);
foreach (var Trans in trans)
{
transactions.Add(Trans);
}
var myTransactions = new TransactionDetailsViewModel
{
Transactions = transactions
};
return(View(myTransactions));
}
public TransactionViewModel(TransactionDetailsViewModel model)
{
TransactionDetails = model;
ClipboardNotificationVisible = false;
ClipboardNotificationOpacity = 0;
CopyTransactionId = ReactiveCommand.CreateFromTask(TryCopyTxIdToClipboardAsync);
OpenTransactionInfo = ReactiveCommand.Create(() =>
{
var shell = IoC.Get <IShell>();
var transactionInfo = shell.Documents?.OfType <TransactionInfoTabViewModel>()?.FirstOrDefault(x => x.Transaction?.TransactionId == TransactionId && x.Transaction?.WalletName == WalletName);
if (transactionInfo is null)
{
transactionInfo = new TransactionInfoTabViewModel(TransactionDetails);
shell.AddDocument(transactionInfo);
}
shell.Select(transactionInfo);
});
Observable
.Merge(CopyTransactionId.ThrownExceptions)
.Merge(OpenTransactionInfo.ThrownExceptions)
.ObserveOn(RxApp.TaskpoolScheduler)
.Subscribe(ex =>
{
Logger.LogError(ex);
NotificationHelpers.Error(ex.ToUserFriendlyString());
});
}
public async Task <IActionResult> Details(string id)
{
var userTransaction = await this.service.RetrieveUserTransaction(id);
var model = new TransactionDetailsViewModel(userTransaction);
return(View(model));
}
public TransactionDetailsView()
{
InitializeComponent();
DataContextChanged += (s, e) =>
{
ViewModel = DataContext as TransactionDetailsViewModel;
};
}
public ActionResult Create()
{
var viewModel = new TransactionDetailsViewModel();
viewModel.CreatedBy = User.Identity.Name;
viewModel.LastUpdatedBy = User.Identity.Name;
viewModel.CreateNewProductSnapshot();
return(View("Create", viewModel));
}
public async Task <ActionResult> Edit(TransactionDetailsViewModel viewModel, CancellationToken cancellationToken)
{
var request = mapper.Map <EditTransactionRequest>(viewModel);
var response = await client.PutAsJsonAsync("transactions", request, cancellationToken);
response.EnsureSuccessStatusCode();
var json = response.Content.ReadAsStringAsync();
var transactionId = JsonConvert.DeserializeObject <Guid>(json.Result);
return(RedirectToAction("Details", new { Id = transactionId }));
}
/// <summary>
/// Report transaction complete
/// </summary>
/// <param name="key">Encoded key for the transaction</param>
/// <returns>Transaction complete view</returns>
/// <remarks>
/// Does not use cookie. Cookie is removed before this step so a new transaction can
/// be started once the transaction has become pending.
/// </remarks>
public ActionResult Complete(string key)
{
var transactionId = Common.Utils.SafeConvert.ToGuid(key.DecryptUrl());
using (var basket = BasketWrapper.CreateByTransaction(dataContextFactory, transactionId))
{
basket.ExecuteComplete();
var viewModel = new TransactionDetailsViewModel(basket.Transaction);
return(View(viewModel));
}
}
public ActionResult Get_EventBookingDetails(int bookingId)
{
TransactionDetailsViewModel _transDetails = new TransactionDetailsViewModel();
try
{
_transDetails = transactionDetails.GetTransactionDetails().FirstOrDefault(x => x.transactionId.Equals(bookingId));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(View(_transDetails));
}
public TransactionDetailsViewModel GetViewModel(Model.Transaction transaction, CurrencyLogic currencyLogic)
{
var viewModel = new TransactionDetailsViewModel
{
Id = transaction.Id,
Name = transaction.Name,
Amount = transaction.Amount,
AccountBalance = transaction.AccountBalance,
SetDate = transaction.SetDate,
Description = transaction.Description,
Currency = currencyLogic.GetCurrencyIconById(transaction.BankAccount.Currency),
BankAccountId = transaction.BankAccount.Id,
UserId = transaction.BankAccount.User.Id
};
return(viewModel);
}
public ActionResult GetSalesSummaryData()
{
IEnumerable <SalesSummaryViewModel> salessummarylist = new List <SalesSummaryViewModel>();
TransactionDetailsViewModel transdetails = new TransactionDetailsViewModel();
//var s=new SalesSummaryViewModel();
try
{
IEnumerable <Booking> bookings = (from booking in _dbEntities.Bookings where booking.is_cancelled != true
//where DbFunctions.TruncateTime(booking.transdate) >= DbFunctions.TruncateTime(startDate) &&
// DbFunctions.TruncateTime(booking.transdate) <= DbFunctions.TruncateTime(endDate)
select booking).ToList();
//IEnumerable<Booking> bookings = (from booking in _dbEntities.Bookings
// where booking.transdate >= startDate &&
// booking.transdate <= endDate
// select booking).ToList();
salessummarylist = (from b in bookings
//join p in _dbEntities.Payments on b.trn_Id equals p.trn_Id into bp
//from p in bp.DefaultIfEmpty()
select new SalesSummaryViewModel()
{
transId = b.trn_Id,
accountname = Utilities.getfullname(b.Customer.lastname, b.Customer.firstname, b.Customer.middle),
dateTrans = Convert.ToDateTime(b.startdate),
//reference =p==null?"No reference" :p.particular,
particular = b.Package.p_descripton + " @ " + b.Package.p_amountPax + " /pax x " + b.noofperson,
CashSales = transdetails.GetTotalPaymentByTrans(b.trn_Id),
OnAccount = transdetails.GetTotalBookingAmount(b.trn_Id) - transdetails.GetTotalPaymentByTrans(b.trn_Id)
}).Where(t => t.OnAccount > 0).ToList();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(Json(new { data = salessummarylist }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Details(int id)
{
var transaction = await _transactionsDataService.RetrieveTransactionAsync(id).ConfigureAwait(false);
if (transaction == null)
{
return(NotFound());
}
var viewModel = new TransactionDetailsViewModel
{
Id = transaction.Id,
Date = transaction.Date,
CategoryId = transaction.CategoryId,
CategoryName = transaction.Category.Name,
Memo = transaction.Memo,
Amount = transaction.Amount,
IsCredit = transaction.IsCredit
};
return(View(viewModel));
}
public async Task <ActionResult> Create(TransactionDetailsViewModel viewModel, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(View("Create", viewModel));
}
viewModel.RemoveEmptyProduct();
viewModel.CalculateProductPrice();
var request = mapper.Map <CreateTransactionRequest>(viewModel);
var response = await client.PostAsJsonAsync("transactions", request, cancellationToken);
//response.EnsureSuccessStatusCode();
if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
return(new HttpStatusCodeResult(System.Net.HttpStatusCode.BadRequest, response.ReasonPhrase));
//ViewBag errorMessage = response.ReasonPhrase;
//return View("Create", viewModel);
}
return(RedirectToAction("Summary"));
}
// GET: PTransactions/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
PTransaction transaction = await _transactionContext.PTransactions.FirstAsync(m => m.Id == id);
PolicyHolder policyHolder = await _policyHolderContext.PolicyHolders.FirstAsync(p => p.Id == transaction.HolderId);
Policy policy = await _policyContext.Policies.FirstAsync(p => p.Id == policyHolder.Id);
IQueryable <Subtransaction> subtransactions = _transactionContext.Subtransactions.Where(s => s.PTransactionId == transaction.Id);
foreach (Subtransaction s in subtransactions)
{
s.CurrentDrug = await _drugContext.Drugs.FirstAsync(d => d.Id == s.DrugId);
}
TransactionDetailsViewModel vm = new TransactionDetailsViewModel(transaction, subtransactions.ToList(), policyHolder, policy);
return(View(vm));
}
/// <summary>
/// Details of a single transaction
/// </summary>
/// <param name="key">Id of the transaction to show</param>
/// <returns>Transaction details view</returns>
public ActionResult Details(string key)
{
var decryptedKey = Common.Utils.SafeConvert.ToGuid(key.DecryptUrl());
using (var context = dataContextFactory.CreateByUser())
{
//Eager loading Transaction
var transactionQuery = (from x in context.Transactions where x.TransactionId == decryptedKey select x)
.Include(x => x.IgnoredItems)
.Include(x => x.TransactionItems.Select(s => s.Sku))
.Include(x => x.TransactionItems.Select(s => s.License))
.Include(x => x.TransactionItems.Select(s => s.License.Domains))
.Include(x => x.TransactionItems.Select(s => s.License.LicenseCustomerApps));
if (transactionQuery.FirstOrDefault() == null)
{
throw new EntityNotFoundException("Transaction could not be resolved!");
}
var viewModel = new TransactionDetailsViewModel(transactionQuery.FirstOrDefault());
return(View(viewModel));
}
}
public TransactionInfoTabViewModel(TransactionDetailsViewModel transaction) : base("")
{
Transaction = transaction;
Title = $"Transaction ({transaction.TransactionId[0..10]}) Details";
public TransactionDetailsPage(int transactionID)
{
InitializeComponent();
this.Title = "FIN - Details";
BindingContext = new TransactionDetailsViewModel(Navigation, transactionID);
}
public TransactionBroadcasterViewModel() : base("Transaction Broadcaster")
{
Global = Locator.Current.GetService <Global>();
ButtonText = "Broadcast Transaction";
this.WhenAnyValue(x => x.FinalTransaction)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x =>
{
try
{
if (x is null)
{
TransactionDetails = null;
}
else
{
TransactionDetails = TransactionDetailsViewModel.FromBuildTxnResult(Global.BitcoinStore, PSBT.FromTransaction(x.Transaction, Global.Network));
NotificationHelpers.Information("Transaction imported successfully!");
}
}
catch (Exception ex)
{
TransactionDetails = null;
NotificationHelpers.Error(ex.ToUserFriendlyString());
Logger.LogError(ex);
}
});
PasteCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
var textToPaste = await Application.Current.Clipboard.GetTextAsync();
if (string.IsNullOrWhiteSpace(textToPaste))
{
FinalTransaction = null;
NotificationHelpers.Information("Clipboard is empty!");
}
else if (PSBT.TryParse(textToPaste, Global.Network ?? Network.Main, out var signedPsbt))
{
if (!signedPsbt.IsAllFinalized())
{
signedPsbt.Finalize();
}
FinalTransaction = signedPsbt.ExtractSmartTransaction();
}
else
{
FinalTransaction = new SmartTransaction(Transaction.Parse(textToPaste, Global.Network ?? Network.Main), WalletWasabi.Models.Height.Unknown);
}
}
catch (Exception ex)
{
FinalTransaction = null;
NotificationHelpers.Error(ex.ToUserFriendlyString());
Logger.LogError(ex);
}
});
IObservable <bool> broadcastTransactionCanExecute = this
.WhenAny(x => x.FinalTransaction, (tx) => tx.Value is { })
public ActionResult getPartialView_AmountDue(int transId)
{
List <BookingAddon> addonslist = new List <BookingAddon>();
TransactionDetailsViewModel _transDetails = new TransactionDetailsViewModel();
try
{
//var transId = transModel.transactionId;
_transDetails = transactionDetails.GetTransactionDetails().FirstOrDefault(x => x.transactionId.Equals(transId));
decimal packageTotal = 0;
decimal addonsTotal = 0;
decimal belowminPax = 0;
decimal extendedLocationAmount = 0;
decimal dpAmount = 0;
decimal fpAmount = 0;
decimal bookdiscountAmount = 0;
decimal cateringdiscountAmount = 0;
string bookdiscountCode = string.Empty;
var packageAmount = _transDetails.Package_Trans.p_amountPax;
var packageType = _transDetails.Package_Trans.p_type;
int no_of_pax = Convert.ToInt32(_transDetails.Booking_Trans.noofperson);
addonslist = _dbcontext.BookingAddons.Where(x => x.trn_Id == transId).ToList();
addonsTotal = addonslist.Sum(y => Convert.ToDecimal(y.AddonAmount));
extendedLocationAmount = transactionDetails.Get_extendedAmountLoc(transId);
//belowminPax = packageType.Trim() == "vip" ? 0 : transactionDetails.GetBelowMinPaxAmount(no_of_pax);
dpAmount = transactionDetails.GetTotalDownPayment(transId);
fpAmount = transactionDetails.GetFullPayment(transId);
cateringdiscountAmount = packageType.Trim() == "vip" ? 0 : transactionDetails.getCateringdiscount(no_of_pax);
//var cateringTotalAmount=cateringdiscountAmount * no_of_pax;
packageTotal = Convert.ToDecimal(packageAmount) * no_of_pax;
var subtotal = (packageTotal + addonsTotal + extendedLocationAmount + belowminPax);
//get discount information
bookdiscountAmount = transactionDetails.Get_bookingDiscountbyTrans(transId, subtotal);
bookdiscountCode = transactionDetails.Get_bookingDiscounDetailstbyTrans(transId);
_transDetails.TotaAddons = addonsTotal;
_transDetails.extLocAmount = extendedLocationAmount;
//_transDetails.TotaBelowMinPax = belowminPax;
_transDetails.TotaDp = dpAmount;
_transDetails.Fullpaymnt = fpAmount;
_transDetails.book_discounts = bookdiscountAmount;
_transDetails.bookdiscountdetails = bookdiscountCode;
_transDetails.cateringdiscount = cateringdiscountAmount;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(PartialView("_BookingsAmountDuePartial", _transDetails));
}
public TransactionInfoTabViewModel(TransactionDetailsViewModel transaction, UiConfig uiConfig) : base(title: "")
{
Transaction = transaction;
UiConfig = uiConfig;
Title = $"Transaction ({transaction.TransactionId[0..10]}) Details";
