private async Task UpdateShoppingCartInfoAsync()
{
string errorMessage = string.Empty;
try
{
_shoppingCart = await _shoppingCartRepository.GetShoppingCartAsync();
if (_shoppingCart != null && _shoppingCart.ShoppingCartItems != null)
{
ShoppingCartItemViewModels = new ObservableCollection <ShoppingCartItemViewModel>();
foreach (var item in _shoppingCart.ShoppingCartItems)
{
var shoppingCartItemViewModel = new ShoppingCartItemViewModel(item, _resourceLoader);
shoppingCartItemViewModel.PropertyChanged += ShoppingCartItemViewModel_PropertyChanged;
ShoppingCartItemViewModels.Add(shoppingCartItemViewModel);
}
CheckoutCommand.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(FullPrice));
RaisePropertyChanged(nameof(TotalDiscount));
RaisePropertyChanged(nameof(TotalPrice));
}
}
catch (Exception ex)
{
errorMessage = string.Format(CultureInfo.CurrentCulture, _resourceLoader.GetString("GeneralServiceErrorMessage"), Environment.NewLine, ex.Message);
}
if (!string.IsNullOrWhiteSpace(errorMessage))
{
await _alertMessageService.ShowAsync(errorMessage, _resourceLoader.GetString("ErrorServiceUnreachable"));
}
}
private async Task Remove(ShoppingCartItemViewModel item)
{
if (item == null)
{
return;
}
string errorMessage = string.Empty;
try
{
// Hide the AppBar
IsBottomAppBarOpened = false;
await _shoppingCartRepository.RemoveShoppingCartItemAsync(item.Id);
ShoppingCartItemViewModels.Remove(item);
CheckoutCommand.RaiseCanExecuteChanged();
RaisePropertyChanged(nameof(FullPrice));
RaisePropertyChanged(nameof(TotalDiscount));
RaisePropertyChanged(nameof(TotalPrice));
}
catch (Exception ex)
{
errorMessage = string.Format(CultureInfo.CurrentCulture, _resourceLoader.GetString("GeneralServiceErrorMessage"), Environment.NewLine, ex.Message);
}
if (!string.IsNullOrWhiteSpace(errorMessage))
{
await _alertMessageService.ShowAsync(errorMessage, _resourceLoader.GetString("ErrorServiceUnreachable"));
}
}
public async Task Handle_EventBusThrowsException_ThrowException(
[Frozen] Mock <IBasketRepository> mockBasketRepository,
[Frozen] Mock <IEventBus> mockEventBus,
CheckoutCommandHandler sut,
CheckoutCommand command,
CustomerBasket basket
)
{
//Arrange
mockBasketRepository.Setup(_ => _.GetBasketAsync(
It.IsAny <string>()
))
.ReturnsAsync(basket);
mockEventBus.Setup(_ => _.Publish(It.IsAny <IntegrationEvent>()))
.Throws <Exception>();
//Act
Func <Task> func = async() => await sut.Handle(command, CancellationToken.None);
//Assert
await func.Should().ThrowAsync <Exception>();
mockBasketRepository.Verify(x => x.GetBasketAsync(
It.IsAny <string>()
));
}
static async Task RunLoop(IEndpointInstance endpointInstance)
{
while (true)
{
log.Info("Press 'P' to place an order, or 'Q' to quit.");
var key = Console.ReadKey();
Console.WriteLine();
switch (key.Key)
{
case ConsoleKey.P:
// Instantiate the command
var command = new CheckoutCommand
{
CartId = Guid.NewGuid(),
CustomerId = Guid.NewGuid()
};
// Send the command
log.Info($"Sending Checkout command, CartId = {command.CartId}");
await endpointInstance.Send(command)
.ConfigureAwait(false);
break;
case ConsoleKey.Q:
return;
default:
log.Info("Unknown input. Please try again.");
break;
}
}
}
private void NotifyCommands()
{
CancelCommand.RaiseCanExecuteChanged();
CheckoutCommand.RaiseCanExecuteChanged();
PrintCommand.RaiseCanExecuteChanged();
PreviewCommand.RaiseCanExecuteChanged();
SearchProductCommand.RaiseCanExecuteChanged();
}
internal static Order FromCheckout(CheckoutCommand command, string userIdentifier)
{
return(new Order
{
UserIdentifier = userIdentifier,
CustomerEmail = command.Customer.Email,
Lines = new List <OrderLine>()
});
}
public User GetCheckoutUser(CheckoutCommand checkoutCommand, FIL.Contracts.Models.Country country)
{
try
{
if (checkoutCommand.IsLoginCheckout)
{
User currentUser = _userRepository.GetByAltId(checkoutCommand.UserAltId);
return(currentUser);
}
else
{
User user = checkoutCommand.GuestUser.SignUpMethodId == null?_userRepository.GetByEmailIdAndChannelId(checkoutCommand.GuestUser.Email, checkoutCommand.ChannelId)
: _userRepository.GetByEmailAndChannel(checkoutCommand.GuestUser.Email, checkoutCommand.ChannelId, checkoutCommand.GuestUser.SignUpMethodId);
if (user == null)
{
Guid userAltId = Guid.NewGuid();
user = new User
{
AltId = userAltId,
Email = checkoutCommand.GuestUser.Email,
Password = _passwordHasher.HashPassword(checkoutCommand.GuestUser.Email, checkoutCommand.GuestUser.Password),
RolesId = 2, // TODO: XXX: Need a default
CreatedBy = userAltId,
CreatedUtc = DateTime.UtcNow,
UserName = checkoutCommand.GuestUser.Email,
FirstName = checkoutCommand.GuestUser.FirstName,
LastName = checkoutCommand.GuestUser.LastName,
PhoneCode = country.Phonecode.ToString(),
PhoneNumber = checkoutCommand.GuestUser.PhoneNumber,
ChannelId = ((checkoutCommand.ChannelId == Channels.Website) ? Channels.Website : Channels.Feel),
SignUpMethodId = SignUpMethods.Regular,
IsEnabled = true,
IsRASVMailOPT = checkoutCommand.GuestUser.IsMailOpt
};
user = _userRepository.Save(user);
}
else
{
user.FirstName = checkoutCommand.GuestUser.FirstName;
user.LastName = checkoutCommand.GuestUser.LastName;
user.PhoneCode = country.Phonecode.ToString();
user.PhoneNumber = checkoutCommand.GuestUser.PhoneNumber;
user = _userRepository.Save(user);
}
return(user);
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
return(new User
{
});
}
}
public Task Handle(CheckoutCommand message, IMessageHandlerContext context)
{
Data.CustomerId = message.CustomerId;
var checkGoodsInStock = new CheckGoodsInStockCommand
{
CartId = message.CartId
};
return(context.SendLocal(checkGoodsInStock));
}
public async Task <ActionResult <OrderResponseDto> > Checkout([FromBody] CheckoutCommand command)
{
var result = await _mediator.Send(command);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
public async Task <IActionResult> CheckoutOrder([FromBody] CheckoutCommand command)
{
if (command == null)
{
return(await Respond(null, new List <Notification> {
new Notification("Order", "Parameters is invalid.")
}));
}
var result = _orderCommandHandler.Handle(command);
return(await Respond(result, _orderCommandHandler.Notifications));
}
static void RunCheckoutProcess()
{
CheckoutModel model = new CheckoutModel();
ICommandHandler checkoutHandler = new CommandHandler();
CheckoutCommand checkoutCmd = new CheckoutCommand(model, ConsoleApp.Action.CheckoutAction.AddOrderedItem);
CommonUtils.ExecuteCommand(checkoutHandler, checkoutCmd);
model = checkoutCmd.Checkout;
checkoutCmd = new CheckoutCommand(model, ConsoleApp.Action.CheckoutAction.CheckForMembership);
CommonUtils.ExecuteCommand(checkoutHandler, checkoutCmd);
model = checkoutCmd.Checkout;
checkoutCmd = new CheckoutCommand(model, ConsoleApp.Action.CheckoutAction.ShowCheckoutResult);
CommonUtils.ExecuteCommand(checkoutHandler, checkoutCmd);
}
public void LoadAllCommands()
{
//OrderCommand order = new OrderCommand();
CommandsCommand help = new CommandsCommand();
EnterCommand enter = new EnterCommand();
CheckinCommand checkin = new CheckinCommand();
CheckoutCommand checkout = new CheckoutCommand();
CurrentSetupCommand currentsetup = new CurrentSetupCommand();
SetupCommand setup = new SetupCommand();
this.Commands = new Collection <ICommand>()
{
help, enter, checkin, checkout, currentsetup, setup
};
}
public virtual void TestFileModeChangeAndContentChangeConflict()
{
if (!FS.DETECTED.SupportsExecute())
{
return;
}
Git git = Git.Wrap(db);
// Add non-executable file
FilePath file = WriteTrashFile("file.txt", "a");
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("commit1").Call();
NUnit.Framework.Assert.IsFalse(db.FileSystem.CanExecute(file));
// Create branch
git.BranchCreate().SetName("b1").Call();
// Make file executable
db.FileSystem.SetExecute(file, true);
git.Add().AddFilepattern("file.txt").Call();
git.Commit().SetMessage("commit2").Call();
// Verify executable and working directory is clean
Status status = git.Status().Call();
NUnit.Framework.Assert.IsTrue(status.GetModified().IsEmpty());
NUnit.Framework.Assert.IsTrue(status.GetChanged().IsEmpty());
NUnit.Framework.Assert.IsTrue(db.FileSystem.CanExecute(file));
WriteTrashFile("file.txt", "b");
// Switch branches
CheckoutCommand checkout = git.Checkout().SetName("b1");
try
{
checkout.Call();
NUnit.Framework.Assert.Fail("Checkout exception not thrown");
}
catch (NGit.Api.Errors.CheckoutConflictException)
{
CheckoutResult result = checkout.GetResult();
NUnit.Framework.Assert.IsNotNull(result);
NUnit.Framework.Assert.IsNotNull(result.GetConflictList());
NUnit.Framework.Assert.AreEqual(1, result.GetConflictList().Count);
NUnit.Framework.Assert.IsTrue(result.GetConflictList().Contains("file.txt"));
}
}
public async Task Handle_BasketDoesNotExist_ReturnNull(
[Frozen] Mock <IBasketRepository> mockBasketRepository,
[Frozen] Mock <IEventBus> mockEventBus,
CheckoutCommandHandler sut,
CheckoutCommand command
)
{
//Arrange
//Act
var result = await sut.Handle(command, CancellationToken.None);
//Assert
result.Should().BeNull();
mockBasketRepository.Verify(x => x.GetBasketAsync(
It.IsAny <string>()
));
mockEventBus.Verify(_ => _.Publish(It.IsAny <IntegrationEvent>()), Times.Never);
}
public ICommandResult Handle(CheckoutCommand command)
{
var order = _orderAdoRepository.GetLastCreatedOrderById(command.OrderId);
if (order == null)
{
AddNotification("Order", "Order isn't found.");
return(null);
}
order.Checkout(command.Name, command.Street, command.City, command.Country, command.CreditCardNumber);
AddNotifications(order.Notifications);
if (Invalid)
{
return(null);
}
_orderAdoRepository.Update(order);
return(new ReturnedItemCommandResult(order.Id, order.Number));
}
public async Task Handle_BasketExists_ReturnBasket(
[Frozen] Mock <IBasketRepository> mockBasketRepository,
[Frozen] Mock <IEventBus> mockEventBus,
CheckoutCommandHandler sut,
CheckoutCommand command,
CustomerBasket basket
)
{
//Arrange
mockBasketRepository.Setup(_ => _.GetBasketAsync(
It.IsAny <string>()
))
.ReturnsAsync(basket);
//Act
var result = await sut.Handle(command, CancellationToken.None);
//Assert
result.Should().BeEquivalentTo(basket);
mockBasketRepository.Verify(_ => _.GetBasketAsync(
It.IsAny <string>()
));
mockEventBus.Verify(_ => _.Publish(It.IsAny <IntegrationEvent>()));
}
public ServiceWizardViewModel(PanaceaServices core, TaskCompletionSource <bool> source)
{
_core = core;
_source = source;
SelectedItems = new ObservableCollection <Service>();
RemoveServiceCommand = new RelayCommand(args =>
{
SelectedItems.Remove(args as Service);
if (!SelectedItems.Any())
{
CartBoxIsOpen = false;
}
});
SwitchToServicesCommand = new RelayCommand(args =>
{
if (SelectedIndex == 0)
{
SelectedIndex = 1;
}
else
{
SelectedIndex = 0;
}
});
BuyServiceCommand = new RelayCommand(arg =>
{
SelectedItems.Clear();
TabsSelectedIndex = 0;
});
CompleteCommand = new RelayCommand(arg =>
{
source.TrySetResult(true);
});
ToggleCartBoxCommand = new RelayCommand(arg =>
{
CartBoxIsOpen = !CartBoxIsOpen;
});
CheckoutCommand = new RelayCommand(async args =>
{
if (Packages != null && Packages.Any(p => p.IsChecked) ||
Services != null && Services.Any(s => s.IsChecked))
{
CartBoxIsOpen = false;
if (core.UserService.User.Id == null)
{
if (core.TryGetUserAccountManager(out IUserAccountManager account))
{
_waitingForAnotherTask = true;
if (await account.RequestLoginAsync("In order to continue, you need to sign in with your user account"))
{
_waitingForAnotherTask = false;
TabsSelectedIndex = 1;
CreateWebBrowser();
BuyService();
}
}
//todo TabsSelectedIndex = 1;
}
else
{
var pop = new UserConfirmationViewModel(_core.UserService.User);
if (_core.TryGetUiManager(out IUiManager ui))
{
var res = await ui.ShowPopup(pop);
if (res == UserConfirmationResult.Confirm)
{
TabsSelectedIndex = 1;
CreateWebBrowser();
BuyService();
//CheckUserService(() =>
//{
// });
}
else if (res == UserConfirmationResult.NotMe)
{
if (!(_core.TryGetUserAccountManager(out IUserAccountManager user) && await user.LogoutAsync()))
{
await _core.UserService.LogoutAsync(); //todo (true)
}
CheckoutCommand.Execute(null);
}
else
{
CartBoxIsOpen = true;
}
}
}
}
else
{
if (core.TryGetUiManager(out IUiManager ui))
{
await ui.ShowPopup(new NoServiceSelectedPopupViewModel());
}
}
});
SelectCommand = new RelayCommand(args =>
{
var package = args as Service;
if (package == null)
{
return;
}
CancelButtonVisibility = Visibility.Collapsed;
CancelButtonServicesVisibility = Visibility.Visible;
if (package is Package)
{
CancelButtonVisibility = Visibility.Visible;
CancelButtonServicesVisibility = Visibility.Collapsed;
SelectedItems.Clear();
Packages.ForEach(lp => lp.IsChecked = false);
Services.ForEach(lp => lp.IsChecked = false);
package.IsChecked = true;
}
else if (SelectedItems.Any(i => i is Package))
{
SelectedItems.Clear();
Packages.ForEach(lp => lp.IsChecked = false);
Services.ForEach(lp => lp.IsChecked = false);
package.IsChecked = true;
}
if (SelectedItems.Contains(package))
{
SelectedItems.Remove(package);
package.IsChecked = false;
CartBoxIsOpen = SelectedItems.Count > 0;
HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
UpdateSum();
TotalPanelVisibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
? Visibility.Visible
: Visibility.Collapsed;
return;
}
if ((package.IsPricePerDay && SelectedItems.Any(s => !s.IsPricePerDay)) ||
(!package.IsPricePerDay && SelectedItems.Any(s => s.IsPricePerDay)))
{
/*todo
* var warning = new ChangeServiceTypeWarning();
* warning.Continue += (oo, ee) =>
* {
* window.ThemeManager.HidePopup(warning);
* SelectedItems.Clear();
* packages.ForEach(lp => lp.IsChecked = false);
* services.ForEach(lp => lp.IsChecked = false);
* package.IsChecked = true;
* SelectedItems.Add(package);
* CartBox.IsOpen = SelectedItems.Count > 0;
* HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
* UpdateSum();
* TotalPanel.Visibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
* ? Visibility.Visible
* : Visibility.Collapsed;
* };
*
* warning.Cancel += (oo, ee) =>
* {
* window.ThemeManager.HidePopup(warning);
* package.IsChecked = false;
* CartBox.IsOpen = SelectedItems.Count > 0;
* };
* CartBoxIsOpen = false;
*
* window.ThemeManager.ShowPopup(warning).Closed += (oo, ee) =>
* {
* package.IsChecked = false;
* };
*/
}
else
{
SelectedItems.Add(package);
CartBoxIsOpen = SelectedItems.Count > 0;
HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
UpdateSum();
TotalPanelVisibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
? Visibility.Visible
: Visibility.Collapsed;
}
});
}
public CheckoutCommandResult CheckTicketLimit(CheckoutCommand checkoutCommand)
{
try
{
FIL.Contracts.Models.EventDetail eventDetail = new Contracts.Models.EventDetail();
bool isPurchase = false;
List <FIL.Contracts.DataModels.Transaction> transactionByData = new List <Contracts.DataModels.Transaction>();
if (checkoutCommand.GuestUser != null && checkoutCommand.GuestUser.Email != null && checkoutCommand.GuestUser.PhoneNumber != null)
{
transactionByData = _transactionRepository.GetSuccessFullTransactionByEmailOrPhoneNumber(checkoutCommand.GuestUser.Email, checkoutCommand.GuestUser.PhoneNumber).Where(s => s.ChannelId == Channels.Website).ToList();
}
if (transactionByData.Count() > 0 && !(bool)checkoutCommand.IsASI)
{
IEnumerable <TransactionDetail> transactionDetails = _transactionDetailRepository.GetByTransactionIds(transactionByData.Select(s => s.Id).Distinct());
IEnumerable <Contracts.DataModels.EventTicketAttribute> eventTicketAttributeDetails = _eventTicketAttributeRepository.GetByEventTicketAttributeIds(transactionDetails.Select(s => s.EventTicketAttributeId).Distinct());
IEnumerable <Contracts.DataModels.EventTicketDetail> eventTicketDetails = _eventTicketDetailRepository.GetByEventTicketDetailIds(eventTicketAttributeDetails.Select(s => s.EventTicketDetailId));
IEnumerable <EventDetail> eventDetails = _eventDetailRepository.GetByEventDetailIds(eventTicketDetails.Select(s => s.EventDetailId).Distinct());
foreach (FIL.Contracts.DataModels.EventDetail itemEventDetail in eventDetails)
{
var filteredOrderEventTicketAttribute = checkoutCommand.EventTicketAttributeList.Where(s => s.EventDetailId == itemEventDetail.Id);
if (filteredOrderEventTicketAttribute.Any())
{
var tEventTicketDetails = eventTicketDetails.Where(w => w.EventDetailId == itemEventDetail.Id).Distinct();
var tETD = eventTicketDetails.Where(s => s.EventDetailId == itemEventDetail.Id);
var tETA = eventTicketAttributeDetails.Where(w => tETD.Select(s => s.Id).Contains(w.EventTicketDetailId));
int transactionTotalTickets = transactionDetails.Where(w => tETA.Select(s => s.Id).Contains(w.EventTicketAttributeId)).Distinct().Select(s => s.TotalTickets).Sum(item => item);
int commanEventTicketAttributesSum = filteredOrderEventTicketAttribute.Select(s => s.TotalTickets).Sum(item => item);
int ticketLimit = 10;
if (itemEventDetail.TicketLimit != null)
{
ticketLimit = (int)itemEventDetail.TicketLimit;
}
if ((commanEventTicketAttributesSum + transactionTotalTickets) > ticketLimit)
{
eventDetail = AutoMapper.Mapper.Map <FIL.Contracts.Models.EventDetail>(itemEventDetail);
isPurchase = true;
break;
}
}
}
}
if (isPurchase && !checkoutCommand.ISRasv)
{
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
EventName = eventDetail.Name,
IsTransactionLimitExceed = true,
IsTicketCategorySoldOut = false
});
}
else
{
return(new CheckoutCommandResult
{
Success = true
});
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
return(new CheckoutCommandResult
{
Success = true
});
}
}
public async Task <ActionResult <CheckoutResult> > Checkout([FromBody] CheckoutCommand checkoutCommand)
{
return(await _mediator.Send(checkoutCommand));
}
/// <summary>
/// 处理KEY
/// </summary>
/// <param name="args"></param>
internal void HandleKey(KeyEventArgs args)
{
// 如果是功能(如上下左右,换页)
if (args.Key >= Key.PageUp && args.Key <= Key.Down)
{
switch (args.Key)
{
case Key.Right:
GoRight();
break;
case Key.Left:
GoLeft();
break;
case Key.Up:
GoUp();
break;
case Key.Down:
GoDown();
break;
case Key.PageUp:
GoLastPage();
break;
case Key.PageDown:
GoNextPage();
break;
}
}
// 如果要增加数量或减少数量
else if (args.Key == Key.Add || args.Key == Key.Subtract || args.Key == Key.Delete)
{
if (CurrentSelectedListNew.Count > 0 && CurrentSelectedListNew[CurrentIndex].NavigateMode == 0)
{
if (args.Key == Key.Delete)
{
var lastIndex = CurrentIndex == 0 ? 1 : CurrentIndex;
var lastPage = CurrentPage;
CurrentSelectedListNew[CurrentIndex].Delete.Execute(CurrentSelectedListNew[CurrentIndex]);
if (this.CurrentSelectedListNew.Count > 1 && CurrentPage == lastPage)
{
bool findIt = false;
for (int i = CurrentSelectedListNew.Count - 1; i >= 0; i--)
{
if (i < lastIndex && !findIt)
{
findIt = true;
CurrentIndex = i;
CurrentSelectedListNew[i].IsNavigated = true;
CurrentSelectedListNew[i].NavigateMode = 0;
}
else
{
CurrentSelectedListNew[i].IsNavigated = false;
CurrentSelectedListNew[i].NavigateMode = 0;
}
}
}
//CalcAndResetPage();
}
else
{
double count = double.Parse(CurrentSelectedListNew[CurrentIndex].CountPos);
if (args.Key == Key.Add)
{
if (count < 99999)
{
CurrentSelectedListNew[CurrentIndex].CountPos = (++count).ToString();
}
if (count == 0)
{
CurrentSelectedListNew[CurrentIndex].CountPos = (1).ToString();
}
}
else if (args.Key == Key.Subtract)
{
if (count <= 1 && Common.GetCommon().IsDecreaseProductCount())
{
if (count == 1)
{
CurrentSelectedListNew[CurrentIndex].CountPos = (-1).ToString();
}
else
{
CurrentSelectedListNew[CurrentIndex].CountPos = (--count).ToString();
}
}
if (count > 1)
{
CurrentSelectedListNew[CurrentIndex].CountPos = (--count).ToString();
}
}
}
}
}
// 如果是改动数字
else if ((args.Key >= Key.D0 && args.Key <= Key.D9) || (args.Key >= Key.NumPad0 && args.Key <= Key.NumPad9) || args.Key == Key.OemPeriod || args.Key == Key.Decimal || args.Key == Key.Back)
{
if (CurrentSelectedListNew.Count > 0)
{
if (CurrentSelectedListNew[CurrentIndex].NavigateMode == 0)
{
if (args.Key == Key.Back)
{
string countStr = CurrentSelectedListNew[CurrentIndex].CountPos;
if (countStr.Length > 1)
{
CurrentSelectedListNew[CurrentIndex].CountPos = countStr.Remove(countStr.Length - 1);
}
else
{
CurrentSelectedListNew[CurrentIndex].CountPos = "0";
}
}
else
{
string keyChar = Common.GetCommon().GetStrFromKey(args.Key);
string[] split = CurrentSelectedListNew[CurrentIndex].CountPos.Split('.');
if (split.Length > 1)
{
if (keyChar == "." || split[1].Length >= 3)
{
return;
}
}
else if (CurrentSelectedListNew[CurrentIndex].CountPos.Length >= 8)
{
return;
}
if (CurrentSelectedListNew[CurrentIndex].CountPos == "0" && keyChar != ".")
{
CurrentSelectedListNew[CurrentIndex].CountPos = keyChar;
}
else
{
CurrentSelectedListNew[CurrentIndex].CountPos += keyChar;
}
}
}
else if (CurrentSelectedListNew[CurrentIndex].NavigateMode == 1)
{
if (args.Key == Key.Back)
{
string unitPriceStr = CurrentSelectedListNew[CurrentIndex].UnitPricePos;
if (unitPriceStr.Length > 1)
{
CurrentSelectedListNew[CurrentIndex].UnitPricePos = unitPriceStr.Remove(unitPriceStr.Length - 1);
}
else
{
CurrentSelectedListNew[CurrentIndex].UnitPricePos = "0";
}
}
else
{
string keyChar = Common.GetCommon().GetStrFromKey(args.Key);
string[] split = CurrentSelectedListNew[CurrentIndex].UnitPricePos.Split('.');
if (split.Length > 1)
{
if (keyChar == "." || split[1].Length >= 2)
{
return;
}
}
else if (CurrentSelectedListNew[CurrentIndex].UnitPricePos.Length >= 8)
{
return;
}
if (CurrentSelectedListNew[CurrentIndex].UnitPricePos == "0" && keyChar != ".")
{
CurrentSelectedListNew[CurrentIndex].UnitPricePos = keyChar;
}
else
{
CurrentSelectedListNew[CurrentIndex].UnitPricePos += keyChar;
}
}
}
}
}
else if (args.Key == Key.Enter)
{
// 回车结账
if (this.CurrentSelectedList.Count > 0)
{
CheckoutCommand.Execute(null);
}
}
}
public void CheckoutCommand()
{
var command = new CheckoutCommand(@"C:\Users\jeffr\Documents\EChest\Big Blocks\Resource Packs\FormatTest");
command.Execute(ViewModel.CheckoutCommand.Type.Branch, "test_branch");
}
public static Task ExecuteAsync(ApplicationServiceContext context, CheckoutCommand command)
=> context.ExecuteAsync <CartState>(command, state => new[] { new CartCheckedoutEvent(Guid.Parse(command.AggregateId.Id)) });
public CheckoutCommandResult SaveTransaction(CheckoutCommand checkoutCommand, IEnumerable <Contracts.Models.EventTicketAttribute> eventTicketAttributeModel, FIL.Contracts.DataModels.User user)
{
try
{
var isPaymentBypass = false;
var StripeAccount = FIL.Contracts.Enums.StripeAccount.None;
List <TransactionDetail> transactionDetailList = new List <TransactionDetail>();
List <FIL.Contracts.Models.CartItemModel> lstEventDetailId = new List <FIL.Contracts.Models.CartItemModel>();
FIL.Contracts.DataModels.Transaction transaction = new FIL.Contracts.DataModels.Transaction();
decimal grossTicketAmount = 0;
long eventDetailId = 0, ticketCategoryId = 0;
decimal netTicketAmount = 0;
decimal totalDiscountAmount = 0;
if (checkoutCommand.IsASI == null)
{
checkoutCommand.IsASI = false;
}
var allETD = _eventTicketDetailRepository.GetByEventTicketDetailsIds(eventTicketAttributeModel.Select(s => s.EventTicketDetailId).Distinct()).Distinct();
var allED = _eventDetailRepository.GetByIds(allETD.Select(s => s.EventDetailId).Distinct()).Distinct();
foreach (Contracts.Commands.Transaction.EventTicketAttribute ticketAttributes in checkoutCommand.EventTicketAttributeList)
{
var currentTA = ticketAttributes;
var transactionType = checkoutCommand.IsQrTransaction ? TransactionType.QRCode : checkoutCommand.TransactionType == TransactionType.Itinerary ? TransactionType.Itinerary : ticketAttributes.TicketType == TicketType.SeasonPackage ? TransactionType.Season : ticketAttributes.TransactionType == TransactionType.LiveOnline ? TransactionType.LiveOnline : ticketAttributes.TransactionType == TransactionType.AddOns ? TransactionType.AddOns : TransactionType.Regular;
decimal discountAmount = 0, donationAmount = 0;
if (ticketAttributes.DiscountedPrice > 0)
{
discountAmount = ticketAttributes.DiscountedPrice;
}
if (ticketAttributes.DonationAmount != null && ticketAttributes.DonationAmount > 0)
{
donationAmount = (decimal)ticketAttributes.DonationAmount;
}
Contracts.Models.EventTicketAttribute checkoutCommandEventTicketAttribute = eventTicketAttributeModel.Where(w => w.Id == ticketAttributes.Id).FirstOrDefault();
decimal pricePerTicket = checkoutCommandEventTicketAttribute.Price;
EventTicketDetail eventTicketDetail = allETD.Where(s => s.Id == checkoutCommandEventTicketAttribute.EventTicketDetailId && s.IsEnabled).FirstOrDefault();
if (eventTicketDetail != null)
{
EventDetail eventDetail = allED.Where(s => s.Id == eventTicketDetail.EventDetailId && s.IsEnabled).FirstOrDefault();
if (eventDetail != null)
{
var visitStartDate = ticketAttributes.VisitDate;
var visitEndDate = ticketAttributes.VisitDate;
if (checkoutCommand.TransactionType == TransactionType.Itinerary)
{
visitStartDate = ticketAttributes.VisitStartTime.Split(":").Count() > 1 ? new DateTime(visitStartDate.Year, visitStartDate.Month, visitStartDate.Day, Convert.ToInt32(ticketAttributes.VisitStartTime.Split(":")[0]), Convert.ToInt32(ticketAttributes.VisitStartTime.Split(":")[1]), 0) : visitStartDate;
visitEndDate = ticketAttributes.VisitEndTime.Split(":").Count() > 1 ? new DateTime(visitEndDate.Year, visitEndDate.Month, visitEndDate.Day, Convert.ToInt32(ticketAttributes.VisitEndTime.Split(":")[0]), Convert.ToInt32(ticketAttributes.VisitEndTime.Split(":")[1]), 0) : visitEndDate;
}
visitStartDate = visitStartDate < new DateTime(1753, 1, 1) ? DateTime.UtcNow : visitStartDate;
visitEndDate = visitEndDate < new DateTime(1753, 1, 1) ? DateTime.UtcNow : visitEndDate;
if ((bool)checkoutCommand.IsASI)
{
pricePerTicket = ticketAttributes.TicketType == TicketType.Child ? 0 : checkoutCommandEventTicketAttribute.Price;
}
if (ticketAttributes.OverridedAmount != null && checkoutCommand.IsBSPUpgrade && ticketAttributes.OverridedAmount != 0)
{
pricePerTicket = (decimal)ticketAttributes.OverridedAmount;
}
if (ticketAttributes.TicketType == TicketType.SeasonPackage)
{
eventDetailId = eventTicketDetail.EventDetailId;
lstEventDetailId.Add(new FIL.Contracts.Models.CartItemModel {
EventDetailId = eventDetailId
});
ticketCategoryId = eventTicketDetail.TicketCategoryId;
IEnumerable <EventDetail> seasonEventDetails = _eventDetailRepository.GetSeasonEventDetails(eventDetail.EventId, eventDetail.VenueId).Where(s => s.IsEnabled == true);
IEnumerable <EventTicketDetail> seasonEventTicketDetails = _eventTicketDetailRepository.GetByEventDetailIds(seasonEventDetails.Select(s => s.Id).Distinct()).Where(w => w.TicketCategoryId == eventTicketDetail.TicketCategoryId);
List <Contracts.DataModels.EventTicketAttribute> seasonEventTicketAttributes = _eventTicketAttributeRepository.GetByEventTicketDetailIds(seasonEventTicketDetails.Select(s => s.Id).Distinct()).Where(W => W.IsEnabled == true && W.SeasonPackage == true).ToList();
var seasonPrice = seasonEventTicketAttributes[0].SeasonPackagePrice;
pricePerTicket = seasonPrice / seasonEventTicketAttributes.Count;
}
else
{
eventDetailId = eventDetail.Id;
lstEventDetailId.Add(new FIL.Contracts.Models.CartItemModel {
EventDetailId = eventTicketDetail.EventDetailId
});
ticketCategoryId = eventTicketDetail.TicketCategoryId;
}
if (Convert.ToInt16(ticketAttributes.TotalTickets) <= checkoutCommandEventTicketAttribute.RemainingTicketForSale)
{
TransactionDetail transactionDetail = new TransactionDetail();
transactionDetail.EventTicketAttributeId = ticketAttributes.Id;
transactionDetail.TotalTickets = Convert.ToInt16(ticketAttributes.TotalTickets);
transactionDetail.PricePerTicket = checkoutCommand.TransactionType == TransactionType.Itinerary ? ticketAttributes.Price : pricePerTicket;
transactionDetail.DiscountAmount = discountAmount;
transactionDetail.VisitDate = visitStartDate;
transactionDetail.VisitEndDate = visitEndDate;
transactionDetail.TransactionType = transactionType;
transactionDetail.TicketTypeId = checkoutCommand.TransactionType == TransactionType.Itinerary ? (short)(ticketAttributes.IsAdult ? 10 : 2) : (short)(TicketType)ticketAttributes.TicketType;
if (checkoutCommand.ReferralId != null)
{
var referral = _referralProvider.GetReferral(checkoutCommand.ReferralId, eventDetail.EventId, checkoutCommand.ModifiedBy);
if (referral != null && referral.Id != 0)
{
transactionDetail.ReferralId = referral.Id;
}
}
if (checkoutCommand.ChannelId == Channels.Feel && checkoutCommand.TransactionType != TransactionType.Itinerary)
{
_geoCurrency.UpdateTransactionUpdates(transactionDetail, checkoutCommand.TargetCurrencyCode, checkoutCommandEventTicketAttribute.CurrencyId);
}
if (donationAmount > 0) // Donation doesn't need the local currency as the amount itself in the local currency
{
transactionDetail.PricePerTicket = transactionDetail.PricePerTicket + donationAmount;
}
netTicketAmount += ((ticketAttributes.TotalTickets * (decimal)transactionDetail.PricePerTicket) - ((decimal)transactionDetail.DiscountAmount));
grossTicketAmount += ((ticketAttributes.TotalTickets * transactionDetail.PricePerTicket));
totalDiscountAmount += (decimal)transactionDetail.DiscountAmount;
transactionDetail.MembershipId = ticketAttributes.MembershipId;
transactionDetailList.Add(transactionDetail);
}
else
{
EventDetail eventDetails = _eventDetailRepository.Get(eventDetailId);
Contracts.DataModels.TicketCategory ticketCategory = _ticketCategoryRepository.Get((int)ticketCategoryId);
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
EventName = eventDetails.Name,
TicketCategoryName = ticketAttributes.TicketType == TicketType.SeasonPackage ? "Season - " + ticketCategory.Name : ticketCategory.Name,
IsTransactionLimitExceed = false,
IsTicketCategorySoldOut = true
});
}
}
else
{
EventDetail eventDetails = _eventDetailRepository.Get(eventDetailId);
Contracts.DataModels.TicketCategory ticketCategory = _ticketCategoryRepository.Get((int)ticketCategoryId);
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
EventName = eventDetails.Name,
TicketCategoryName = ticketAttributes.TicketType == TicketType.SeasonPackage ? "Season - " + ticketCategory.Name : ticketCategory.Name,
IsTransactionLimitExceed = false,
IsTicketCategorySoldOut = true
});
}
}
else
{
EventDetail eventDetails = _eventDetailRepository.Get(eventDetailId);
Contracts.DataModels.TicketCategory ticketCategory = _ticketCategoryRepository.Get((int)ticketCategoryId);
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
EventName = eventDetails.Name,
TicketCategoryName = ticketAttributes.TicketType == TicketType.SeasonPackage ? "Season - " + ticketCategory.Name : ticketCategory.Name,
IsTransactionLimitExceed = false,
IsTicketCategorySoldOut = true
});
}
}
var intialCurrencyId = eventTicketAttributeModel.Select(s => s.CurrencyId).FirstOrDefault();
var currencyId = eventTicketAttributeModel.Select(s => s.CurrencyId).FirstOrDefault();
if (checkoutCommand.ChannelId == Channels.Feel) // Update the currencyId
{
if (checkoutCommand.TransactionType == TransactionType.Itinerary)
{
currencyId = _geoCurrency.GetCurrencyID(checkoutCommand.TransactionCurrency).Id;
}
else
{
currencyId = _geoCurrency.GetCurrencyID(checkoutCommand.TargetCurrencyCode).Id;
}
}
/*if (checkoutCommand.ISRasv) // NAB test bed
* {
* var splitprice = netTicketAmount.ToString("0.00").Split(".");
* var price = splitprice[0] + ".00";
* netTicketAmount = Convert.ToDecimal(netTicketAmount);
* }*/
transaction.ChannelId = checkoutCommand.ChannelId;
transaction.CurrencyId = currencyId;
transaction.TotalTickets = Convert.ToInt16(checkoutCommand.EventTicketAttributeList.Sum(s => s.TotalTickets));
transaction.GrossTicketAmount = grossTicketAmount;
transaction.NetTicketAmount = netTicketAmount;
transaction.DiscountAmount = totalDiscountAmount;
transaction.TransactionStatusId = TransactionStatus.UnderPayment;
transaction.FirstName = user.FirstName;
transaction.LastName = user.LastName;
transaction.PhoneCode = user.PhoneCode;
transaction.PhoneNumber = user.Email == "*****@*****.**" ? checkoutCommand.GuestUser.PhoneNumber : user.PhoneNumber;
transaction.EmailId = user.Email == "*****@*****.**" ? checkoutCommand.GuestUser.PhoneNumber : user.Email;
transaction.CountryName = !string.IsNullOrWhiteSpace(user.PhoneCode) ? _countryRepository.GetByPhoneCode(user.PhoneCode).Name : "India";
transaction.CreatedBy = user.AltId;
transaction.CreatedUtc = DateTime.UtcNow;
try
{
var ipDetail = _saveIPProvider.SaveIp(checkoutCommand.Ip);
if (ipDetail != null && ipDetail.Id > 0)
{
transaction.IPDetailId = ipDetail.Id;
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
transaction.IPDetailId = 1;
}
transaction.ModifiedBy = user.AltId;
transaction.AltId = Guid.NewGuid();
if (transaction.CurrencyId != 7)
{
transaction.OTP = checkoutCommand.OTPCode;
}
if (checkoutCommand.DonationAmount != null && checkoutCommand.DonationAmount != 0)
{
transaction.DonationAmount = checkoutCommand.DonationAmount;
}
FIL.Contracts.DataModels.Transaction transactionResult = _transactionRepository.Save(transaction);
foreach (TransactionDetail transactionDetail in transactionDetailList)
{
transactionDetail.TransactionId = transactionResult.Id;
var currentTransactionDetail = _transactionDetailRepository.Save(transactionDetail);
FIL.Contracts.DataModels.EventTicketAttribute eventTicketAttribute = AutoMapper.Mapper.Map <FIL.Contracts.DataModels.EventTicketAttribute>(_eventTicketAttributeRepository.Get(transactionDetail.EventTicketAttributeId));
FIL.Contracts.DataModels.EventTicketDetail eventTicketDetail = AutoMapper.Mapper.Map <FIL.Contracts.DataModels.EventTicketDetail>(_eventTicketDetailRepository.Get(eventTicketAttribute.EventTicketDetailId));
if (Convert.ToInt16(transactionDetail.TotalTickets) <= eventTicketAttribute.RemainingTicketForSale)
{
eventTicketAttribute.RemainingTicketForSale -= transactionDetail.TotalTickets;
_eventTicketAttributeRepository.Save(eventTicketAttribute);
if (checkoutCommand.ChannelId == Channels.Website)
{
if (eventTicketDetail.InventoryTypeId == InventoryType.Seated || eventTicketDetail.InventoryTypeId == InventoryType.SeatedWithSeatSelection || eventTicketDetail.InventoryTypeId == InventoryType.NoneSeated)
{
List <Contracts.Models.TMS.SeatDetail> seatDetail = new List <Contracts.Models.TMS.SeatDetail>();
if (checkoutCommand.SeatDetails != null)
{
seatDetail = AutoMapper.Mapper.Map <List <Contracts.Models.TMS.SeatDetail> >(checkoutCommand.SeatDetails.Where(w => w.EventTicketDetailId == eventTicketDetail.Id));
}
else
{
seatDetail = null;
}
var seatBlock = _seatBlockingProvider.BlockSeat(seatDetail, transactionDetail, eventTicketAttribute, eventTicketDetail, user.AltId, Channels.Website);
if (!seatBlock.Success && seatBlock.IsSeatSoldOut)
{
return(new CheckoutCommandResult
{
Success = false,
Id = 0,
TransactionAltId = Guid.NewGuid(),
IsTransactionLimitExceed = false,
IsTicketCategorySoldOut = false,
IsSeatSoldOut = true
});
}
}
}
}
else
{
EventDetail eventDetails = _eventDetailRepository.Get(eventDetailId);
Contracts.DataModels.TicketCategory ticketCategory = _ticketCategoryRepository.Get((int)ticketCategoryId);
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
EventName = eventDetails.Name,
TicketCategoryName = transactionDetail.TicketTypeId == (short)TicketType.SeasonPackage ? "Season - " + ticketCategory.Name : ticketCategory.Name,
IsTransactionLimitExceed = false,
IsTicketCategorySoldOut = true
});
}
/* Save Transaction Schedule Detail */
var currentTicket = checkoutCommand.EventTicketAttributeList.Where(s => s.Id == currentTransactionDetail.EventTicketAttributeId).FirstOrDefault();
if (currentTicket.ScheduleDetailId != null && currentTicket.ScheduleDetailId != 0)
{
_saveTransactionScheduleDetailProvider.SaveTransactionScheduleDetail(currentTransactionDetail.Id, (long)currentTicket.ScheduleDetailId);
}
}
try
{
if (checkoutCommand.ChannelId == Channels.Feel || checkoutCommand.ChannelId == Channels.Website) // If Live Online Transaction with 0.00 price
{
var @event = _eventRepository.Get(allED.FirstOrDefault().EventId);
if (@event != null)
{
if (@event.MasterEventTypeId == Contracts.Enums.MasterEventType.Online && transaction.NetTicketAmount == 0)
{
_zoomMeetingProvider.CreateMeeting(transaction, true);
isPaymentBypass = true;
}
else if (@event.MasterEventTypeId == Contracts.Enums.MasterEventType.Online)
{
StripeAccount = _eventStripeConnectAccountProvider.GetEventStripeAccount(allED.FirstOrDefault().EventId, checkoutCommand.ChannelId);
}
}
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
}
try
{
/*Check if referred transactionId already upgraded to BSP or successfull transaction, if yes then don't allow another transaction using same referral/ transaction id*/
if (checkoutCommand.IsBSPUpgrade && checkoutCommand.ReferralId != null)
{
var transactions = _transactionRepository.GetAllSuccessfulTransactionByReferralId(checkoutCommand.ReferralId);
if (transactions.Any())
{
return(new CheckoutCommandResult
{
Id = 0,
Success = false,
IsBSPUpgraded = true
});
}
}
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
}
return(new CheckoutCommandResult
{
Id = transactionResult.Id,
CartBookingModel = lstEventDetailId,
Transaction = transactionResult,
IsPaymentByPass = isPaymentBypass,
Success = true,
StripeAccount = StripeAccount,
});
}
catch (Exception e)
{
_logger.Log(Logging.Enums.LogCategory.Error, e);
return(new CheckoutCommandResult
{
});
}
}
