public TransactionDetailPage(Transaction trans, IHasBalance fromModel)
{
TransactionDetailViewModel vm = new TransactionDetailViewModel(trans, Navigation, fromModel);
BindingContext = vm;
InitializeComponent();
}
public TransactionDetailPage(Transaction trans)
{
TransactionDetailViewModel vm = new TransactionDetailViewModel(trans, Navigation);
BindingContext = vm;
InitializeComponent();
}
public TransactionDetailViewModel GetCompensationRegionModel()
{
var regions = new List <SelectListItem>();
var codes = new List <SelectListItem>();
var compensationRegions = CompensationRegionService.GetAllCompensationRegions();
regions.Add(new SelectListItem {
Value = "0", Text = "--Seleccione--"
});
codes.Add(new SelectListItem {
Value = "0", Text = "--Seleccione--"
});
foreach (var compensationRegion in compensationRegions)
{
regions.Add(new SelectListItem
{
Value = compensationRegion.CompensationRegionId.ToString(),
Text = compensationRegion.Region.ToString()
});
codes.Add(new SelectListItem
{
Value = compensationRegion.CompensationRegionId.ToString(),
Text = compensationRegion.Code.ToString()
});
}
var model = new TransactionDetailViewModel();
model.CompensationCodeList = codes;
model.CompensationRegionList = regions;
return(model);
}
public ActionResult GetTransactionDetails(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Transaction t = db.Transactions.Find(id);
if (t == null)
{
return(HttpNotFound());
}
TransactionDetailViewModel tdvm = new TransactionDetailViewModel();
List <TransactionItemDetailViewModel> l_tidvm = new List <TransactionItemDetailViewModel>();
foreach (TransactionItem ti in t.TransactionItems)
{
TransactionItemDetailViewModel tidvm = new TransactionItemDetailViewModel();
tidvm.item_name = ti.item_name;
tidvm.item_quantity = ti.quantity;;
tidvm.item_price = ti.item_price;
tidvm.total_price = ti.item_price * ti.quantity;
l_tidvm.Add(tidvm);
}
tdvm.username = t.Account.username;
tdvm.transaction_items = l_tidvm;
return(PartialView("TransactionDetails", tdvm));
}
public void DeleteTransactionDetail(TransactionDetailViewModel detail)
{
TransactionDetail entity = _transactionDetailRepository.GetById(detail.Id);
_transactionDetailRepository.Delete(entity);
_unitOfWork.SaveChanges();
}
public ActionResult TransactionDetailUpdate(TransactionDetailViewModel detail, string delete, string account)
{
if (!string.IsNullOrEmpty(delete))
{
if (ModelState.IsValid)
{
InitializeService.Settings.Services.Business.TransactionService.TransactionDelete(account);
return(RedirectToAction("TransactionLog"));
}
}
else
{
if (ModelState.IsValid)
{
InitializeService.Settings.Services.Business.TransactionService.UpdateTransaction(new Entities.Transact
{
Account = detail.Account,
Description = detail.Description,
CurrencyCode = detail.CurrencyCode,
Amount = detail.Amount
});
return(RedirectToAction("TransactionLog"));
}
}
return(RedirectToAction("TransactionLog"));
}
public async Task <string> SaveTransaction(UserIdentityViewModel user, TransactionDetailViewModel model)
{
if (string.IsNullOrEmpty(model.TransactionNo))
{
return(await CreateTransaction(user, model));
}
else
{
return(await UpdateTransaction(user, model));
}
}
public TransactionDetailPage()
{
InitializeComponent();
var tx = new Transaction
{
Value = 0,
Description = ""
};
viewModel = new TransactionDetailViewModel(tx);
BindingContext = viewModel;
}
public ActionResult TransactionDetail(string id)
{
var model = new TransactionDetailViewModel();
if (id != "-1")
{
var transaction = InitializeService.Settings.Services.Business.TransactionService.TransactionGetById(id);
model.Account = transaction.Account;
model.Description = transaction.Description;
model.CurrencyCode = transaction.CurrencyCode;
model.Amount = transaction.Amount;
}
return(View("~/Views/Transaction/TransactionDetail.cshtml", model));
}
public async Task <TransactionDetailViewModel> GetTransationDetail(int id)
{
var transaction = await UnitOfWork.TransactionRepository.Find(id);
var vm = new TransactionDetailViewModel
{
Id = transaction.Id,
Date = transaction.TransactionDate.ToString("d"),
Status = GetDescription(transaction.TransactionStatus),
TransactionAmount = transaction.TransactionAmount.ToString("C"),
Delivery = transaction.Delivery,
Payment = transaction.Payment,
BookQuantities = transaction.TransactionBookQuantities,
DeliveryAddress = transaction.DeliveryAddress
};
return(vm);
}
public HttpResponseMessage Update(HttpRequestMessage request, TransactionDetailViewModel propVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var dbTransactionDetail = _transactionDetailService.GetById(propVM.ID);
dbTransactionDetail.UpdateTransactionDetail(propVM);
_transactionDetailService.Update(dbTransactionDetail);
_transactionDetailService.Save();
var responseData = Mapper.Map <TransactionDetail, TransactionDetailViewModel>(dbTransactionDetail);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public HttpResponseMessage Create(HttpRequestMessage request, TransactionDetailViewModel transactionDetailVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newTransactionDetail = new TransactionDetail();
newTransactionDetail.UpdateTransactionDetail(transactionDetailVM);
_transactionDetailService.Add(newTransactionDetail);
_transactionDetailService.Save();
var responseData = Mapper.Map <TransactionDetail, TransactionDetailViewModel>(newTransactionDetail);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public IActionResult Detail(string id)
{
var model = new TransactionDetailViewModel();
try
{
model.Transaction = FetchTransaction(id).Collections.FirstOrDefault();
var urlGetUser = $"{CreateServiceUrl(Constant.ConfigKey.ApiUrlUser)}{model.Transaction?.CreatedById}";
var responseGetUser = Requestor().Get <CollectionResponse <User> >(urlGetUser);
CheckResponse(responseGetUser);
model.User = responseGetUser.Collections.FirstOrDefault();
}
catch (Exception e)
{
SetErrorMessage(e);
}
return(View(model));
}
private async Task <string> UpdateTransaction(UserIdentityViewModel user, TransactionDetailViewModel model)
{
try
{
var transaction = _unitOfWork.TransactionRepository.All().FirstOrDefault(s => s.TransactionId == model.TransactionId);
if (transaction == null)
{
return("Transaction.NotExist");
}
transaction.ReceiverId = model.ReceiverId;
transaction.CurrencyId = model.CurrencyId;
transaction.Amount = model.Amount;
transaction.UpdatedOn = DateTimeOffset.Now;
transaction.UpdatedBy = user.UserId;
await _unitOfWork.SaveChangeAsync();
}
catch (Exception ex)
{
return("Transaction.SaveError");
}
return("Transaction.SaveSuccess");
}
private async Task <string> CreateTransaction(UserIdentityViewModel user, TransactionDetailViewModel model)
{
try
{
var transaction = new Transaction
{
TransactionNo = GenerateTransactionNo(model.CustomerId),
ReceiverId = model.ReceiverId,
CurrencyId = model.CurrencyId,
Amount = model.Amount,
Status = (int)Status.New,
CreatedOn = DateTimeOffset.Now,
CreatedBy = user.UserId
};
_unitOfWork.TransactionRepository.Add(transaction);
await _unitOfWork.SaveChangeAsync();
}
catch (Exception e)
{
return("Transaction.SaveError");
}
return("Transaction.SaveSuccess");
}
public IActionResult GetForYearRange(int from, int to)
{
List <TransactionDetailViewModel> transactions = new List <TransactionDetailViewModel>();
try
{
foreach (var transaction in _transactionService.FetchForYearRange(from, to))
{
var viewModel = new TransactionDetailViewModel
{
Id = transaction.Id,
PaymentMethod = transaction.PaymentMethod.Name,
Category = transaction.Category.Name,
PayedTo = transaction.PayedTo,
Date = transaction.Date,
TransactionType = transaction.TransactionType.Name,
Notes = transaction.Notes,
Amount = transaction.Amount
};
transactions.Add(viewModel);
}
return(Json(new JsonResponse {
Successful = true,
Error = string.Empty,
Data = transactions
}));
}
catch (Exception ex)
{
return(Json(new JsonResponse {
Successful = false, Error = ex.Message, Data = null
}));
}
}
public async Task <IActionResult> TransactionDetailAsync(int Id)
{
Transaction transaction = await _transactionRepository.GetPurchaseByIdAsync(Id);
Lease lease = transaction.Lease;
RentalAsset rentalAsset = await _rentalAssetRepository.GetItemByIdAsync(lease.RentalAssetId);
VendorUser vendor = await _vendorUserManager.FindByIdAsync(lease.UserId);
ApplicationUser server = await _userManager.FindByIdAsync(transaction.ServerId);
var vm = new TransactionDetailViewModel
{
RentalAsset = rentalAsset,
Transaction = transaction,
VendorUser = vendor,
Server = server,
Lease = lease
};
return(View(vm));
}
public TransactionDetailPage(TransactionDetailViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
}
public void DeleteTransactionDetail(TransactionDetailViewModel detail)
{
TransactionDetail entity = _transactionDetailRepository.GetById(detail.Id);
_transactionDetailRepository.Delete(entity);
_unitOfWork.SaveChanges();
}
public static void UpdateTransactionDetail(this TransactionDetail transactionDetail, TransactionDetailViewModel vm)
{
transactionDetail.CreatedBy = vm.CreatedBy;
transactionDetail.CreatedDate = vm.CreatedDate;
transactionDetail.ID = vm.ID;
transactionDetail.MetaDescription = vm.MetaDescription;
transactionDetail.MetaKeyWord = vm.MetaKeyWord;
transactionDetail.Money = vm.Money;
transactionDetail.PropertyServiceId = vm.PropertyServiceId;
transactionDetail.Status = vm.Status;
transactionDetail.TransactionId = vm.TransactionID;
transactionDetail.UpdatedBy = vm.UpdatedBy;
transactionDetail.UpdatedDate = vm.UpdatedDate;
}
public TransactionDetailPage(TransactionDetailViewModel m)
{
model = m;
}
public ActionResult GetTransactionDetails(int? id)
{
if(id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Transaction t = db.Transactions.Find(id);
if(t == null)
{
return HttpNotFound();
}
TransactionDetailViewModel tdvm = new TransactionDetailViewModel();
List<TransactionItemDetailViewModel> l_tidvm = new List<TransactionItemDetailViewModel>();
foreach(TransactionItem ti in t.TransactionItems)
{
TransactionItemDetailViewModel tidvm = new TransactionItemDetailViewModel();
tidvm.item_name = ti.item_name;
tidvm.item_quantity = ti.quantity; ;
tidvm.item_price = ti.item_price;
tidvm.total_price = ti.item_price * ti.quantity;
l_tidvm.Add(tidvm);
}
tdvm.username = t.Account.username;
tdvm.transaction_items = l_tidvm;
return PartialView("TransactionDetails", tdvm);
}
