public void Handle(CreateReportOrder command)
{
var order = _repository.Find(command.OrderId);
if (order == null)
{
order = new Order(command.OrderId);
}
order.UpdateOrderReportCreated(command.AccountId, command.PickupDate,
command.PickupAddress, command.DropOffAddress, command.Settings, command.EstimatedFare,
command.UserAgent, command.ClientLanguageCode, command.UserLatitude, command.UserLongitude,
command.UserNote, command.ClientVersion, command.IsChargeAccountPaymentWithCardOnFile,
command.CompanyKey, command.CompanyName, command.Market, command.IsPrepaid, command.BookingFees, command.Error, command.TipIncentive,
command.IbsInformationNote, command.Fare, command.IbsAccountId, command.Prompts, command.PromptsLength,
command.PromotionId, command.IsFutureBooking, command.ReferenceDataCompanyList, command.IbsOrderId,
command.OriginatingIpAddress, command.KountSessionId, command.AssignVehicleId);
if (command.Payment.PayWithCreditCard)
{
var payment = Mapper.Map <PaymentInformation>(command.Payment);
order.SetPaymentInformation(payment);
}
_repository.Save(order, command.Id.ToString());
}
private void ThrowAndLogException(CreateReportOrder createReportOrder, ErrorCode errorCodeType, string errorMessage = null)
{
var createOrderException = new HttpError(HttpStatusCode.BadRequest, errorCodeType.ToString(), errorMessage);
createReportOrder.Error = createOrderException.ToString();
_commandBus.Send(createReportOrder);
throw createOrderException;
}
internal BestAvailableCompany FindSpecificCompany(string market, CreateReportOrder createReportOrder, string orderCompanyKey = null, int?orderFleetId = null, double?latitude = null, double?longitude = null)
{
if (!orderCompanyKey.HasValue() && !orderFleetId.HasValue)
{
Exception createOrderException = new ArgumentNullException("You must at least provide a value for orderCompanyKey or orderFleetId");
createReportOrder.Error = createOrderException.ToString();
_commandBus.Send(createReportOrder);
throw createOrderException;
}
var homeCompanyKey = _serverSettings.ServerData.TaxiHail.ApplicationKey;
var fleets = market.HasValue()
? _taxiHailNetworkServiceClient.GetMarketFleets(homeCompanyKey, market).ToArray()
: _taxiHailNetworkServiceClient.GetNetworkFleet(homeCompanyKey, latitude, longitude).ToArray();
if (orderCompanyKey.HasValue())
{
var match = fleets.FirstOrDefault(f => f.CompanyKey == orderCompanyKey);
if (match != null)
{
return(new BestAvailableCompany
{
CompanyKey = match.CompanyKey,
CompanyName = match.CompanyName,
FleetId = match.FleetId
});
}
}
if (orderFleetId.HasValue)
{
var match = fleets.FirstOrDefault(f => f.FleetId == orderFleetId.Value);
if (match != null)
{
return(new BestAvailableCompany
{
CompanyKey = match.CompanyKey,
CompanyName = match.CompanyName,
FleetId = match.FleetId
});
}
}
// Nothing found
return(new BestAvailableCompany());
}
private void ValidateAppVersion(string clientLanguage, CreateReportOrder createReportOrder)
{
var appVersionString = base.Request.Headers.Get("ClientVersion");
var minimumAppVersionString = _serverSettings.ServerData.MinimumRequiredAppVersion;
if (appVersionString.IsNullOrEmpty() || minimumAppVersionString.IsNullOrEmpty())
{
return;
}
var mobileVersion = new ApplicationVersion(appVersionString);
var minimumAppVersion = new ApplicationVersion(minimumAppVersionString);
if (mobileVersion < minimumAppVersion)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrderInvalidVersion", clientLanguage));
}
}
internal InitializePayPalCheckoutResponse InitializePayPalCheckoutIfNecessary(
Guid accountId, bool isPrepaid, Guid orderId, Contract.Requests.CreateOrderRequest request,
decimal bookingFees, string companyKey, CreateReportOrder createReportOrder, string absoluteRequestUri)
{
if (isPrepaid &&
request.Settings.ChargeTypeId == ChargeTypes.PayPal.Id)
{
var paypalWebPaymentResponse = _payPalServiceFactory.GetInstance(companyKey).InitializeWebPayment(accountId, orderId, absoluteRequestUri, request.Estimate.Price, bookingFees, request.ClientLanguageCode);
if (paypalWebPaymentResponse.IsSuccessful)
{
return(paypalWebPaymentResponse);
}
var createOrderException = new HttpError(HttpStatusCode.BadRequest, ErrorCode.CreateOrder_RuleDisable.ToString(), paypalWebPaymentResponse.Message);
createReportOrder.Error = createOrderException.ToString();
_commandBus.Send(createReportOrder);
throw createOrderException;
}
return(null);
}
private Guid?ValidatePromotion(string companyKey, string promoCode, int?chargeTypeId, Guid accountId, DateTime pickupDate, bool isFutureBooking, string clientLanguageCode, CreateReportOrder createReportOrder)
{
if (!promoCode.HasValue())
{
// No promo code entered
return(null);
}
var usingPaymentInApp = chargeTypeId == ChargeTypes.CardOnFile.Id || chargeTypeId == ChargeTypes.PayPal.Id;
if (!usingPaymentInApp)
{
var payPalIsEnabled = _serverSettings.GetPaymentSettings(companyKey).PayPalClientSettings.IsEnabled;
var cardOnFileIsEnabled = _serverSettings.GetPaymentSettings(companyKey).IsPayInTaxiEnabled;
var promotionErrorResourceKey = "CannotCreateOrder_PromotionMustUseCardOnFile";
if (payPalIsEnabled && cardOnFileIsEnabled)
{
promotionErrorResourceKey = "CannotCreateOrder_PromotionMustUseCardOnFileOrPayPal";
}
else if (payPalIsEnabled)
{
promotionErrorResourceKey = "CannotCreateOrder_PromotionMustUsePayPal";
}
// Should never happen since we will check client-side if there's a promocode and not paying with CoF/PayPal
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get(promotionErrorResourceKey, clientLanguageCode));
}
var promo = _promotionDao.FindByPromoCode(promoCode);
if (promo == null)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_PromotionDoesNotExist", clientLanguageCode));
}
var promoDomainObject = _promoRepository.Get(promo.Id);
string errorMessage;
if (!promoDomainObject.CanApply(accountId, pickupDate, isFutureBooking, out errorMessage))
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get(errorMessage, clientLanguageCode));
}
return(promo.Id);
}
private void ValidatePayPal(string companyKey, Guid orderId, AccountDetail account, string clientLanguageCode, bool isFutureBooking, decimal?appEstimateWithTip, decimal bookingFees, CreateReportOrder createReportOrder)
{
if (!_serverSettings.GetPaymentSettings(companyKey).PayPalClientSettings.IsEnabled ||
!account.IsPayPalAccountLinked)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_PayPalButNoPayPal", clientLanguageCode));
}
var isSuccessful = PaymentHelper.PreAuthorizePaymentMethod(companyKey, orderId, account, isFutureBooking, appEstimateWithTip, bookingFees);
if (!isSuccessful)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_PayPalWasDeclined", clientLanguageCode));
}
}
private void ValidateCreditCard(AccountDetail account, string clientLanguageCode, string cvv, CreateReportOrder createReportOrder)
{
// check if the account has a credit card
if (!account.DefaultCreditCard.HasValue)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_CardOnFileButNoCreditCard,
GetCreateOrderServiceErrorMessage(ErrorCode.CreateOrder_CardOnFileButNoCreditCard, clientLanguageCode));
}
var creditCard = _creditCardDao.FindById(account.DefaultCreditCard.GetValueOrDefault());
if (creditCard.IsExpired())
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_CreditCardExpired", clientLanguageCode));
}
if (creditCard.IsDeactivated)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_CardOnFileDeactivated, _resources.Get("CannotCreateOrder_CreditCardDeactivated", clientLanguageCode));
}
if (_serverSettings.GetPaymentSettings().AskForCVVAtBooking &&
!cvv.HasValue())
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_CreditCardCvvRequired", clientLanguageCode));
}
}
private void ValidatePayment(string companyKey, CreateOrderRequest request, Guid orderId, AccountDetail account, bool isFutureBooking, double?appEstimate, decimal bookingFees, bool isPrepaid, CreateReportOrder createReportOrder)
{
var tipPercent = account.DefaultTipPercent ?? _serverSettings.ServerData.DefaultTipPercentage;
// If there's an estimate, add tip to that estimate
if (appEstimate.HasValue)
{
appEstimate = appEstimate.Value + FareHelper.CalculateTipAmount(appEstimate.Value, tipPercent);
}
var appEstimateWithTip = appEstimate.HasValue ? Convert.ToDecimal(appEstimate.Value) : (decimal?)null;
if (isPrepaid)
{
// Verify that prepaid is enabled on the server
if (!_serverSettings.GetPaymentSettings(companyKey).IsPrepaidEnabled)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
_resources.Get("CannotCreateOrder_PrepaidButPrepaidNotEnabled", request.ClientLanguageCode));
}
// Payment mode is CardOnFile
if (request.Settings.ChargeTypeId.HasValue &&
request.Settings.ChargeTypeId.Value == ChargeTypes.CardOnFile.Id)
{
if (!appEstimateWithTip.HasValue)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
_resources.Get("CannotCreateOrder_PrepaidNoEstimate", request.ClientLanguageCode));
}
ValidateCreditCard(account, request.ClientLanguageCode, request.Cvv, createReportOrder);
var result = PaymentHelper.CapturePaymentForPrepaidOrder(companyKey, orderId, account, Convert.ToDecimal(appEstimateWithTip), tipPercent, bookingFees, request.Cvv);
if (!result.IsSuccessful)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, result.Message);
}
}
}
else
{
// Payment mode is CardOnFile
if (request.Settings.ChargeTypeId.HasValue &&
request.Settings.ChargeTypeId.Value == ChargeTypes.CardOnFile.Id)
{
ValidateCreditCard(account, request.ClientLanguageCode, request.Cvv, createReportOrder);
var isSuccessful = PaymentHelper.PreAuthorizePaymentMethod(companyKey, orderId, account,
isFutureBooking, appEstimateWithTip, bookingFees, request.Cvv);
if (!isSuccessful)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
_resources.Get("CannotCreateOrder_CreditCardWasDeclined", request.ClientLanguageCode));
}
}
// Payment mode is PayPal
if (request.Settings.ChargeTypeId.HasValue &&
request.Settings.ChargeTypeId.Value == ChargeTypes.PayPal.Id)
{
ValidatePayPal(companyKey, orderId, account, request.ClientLanguageCode, isFutureBooking, appEstimateWithTip, bookingFees, createReportOrder);
}
}
}
private void ValidateChargeAccountAnswers(string accountNumber, string customerNumber,
IEnumerable <AccountChargeQuestion> userQuestionsDetails, string clientLanguageCode, CreateReportOrder createReportOrder)
{
var accountChargeDetail = _accountChargeDao.FindByAccountNumber(accountNumber);
if (accountChargeDetail == null)
{
ThrowAndLogException(createReportOrder, ErrorCode.AccountCharge_InvalidAccountNumber,
GetCreateOrderServiceErrorMessage(ErrorCode.AccountCharge_InvalidAccountNumber, clientLanguageCode));
}
var answers = userQuestionsDetails.Select(x => x.Answer)
.Where(x => x.HasValueTrimmed());
var validation = _ibsServiceProvider.ChargeAccount().ValidateIbsChargeAccount(answers, accountNumber, customerNumber);
if (validation.Valid)
{
return;
}
if (validation.ValidResponse != null)
{
var firstError = validation.ValidResponse.IndexOf(false);
string errorMessage = null;
if (accountChargeDetail != null)
{
errorMessage = accountChargeDetail.Questions[firstError].ErrorMessage;
}
ThrowAndLogException(createReportOrder, ErrorCode.AccountCharge_InvalidAnswer, errorMessage);
}
ThrowAndLogException(createReportOrder, ErrorCode.AccountCharge_InvalidAccountNumber, validation.Message);
}
private ChargeAccountValidationResult ValidateChargeAccountIfNecessary(string companyKey, CreateOrderRequest request, Guid orderId, AccountDetail account, bool isFutureBooking, bool isFromWebApp, decimal bookingFees, CreateReportOrder createReportOrder)
{
string[] prompts = null;
int?[] promptsLength = null;
string chargeTypeOverride = null;
var isChargeAccountPaymentWithCardOnFile = false;
if (request.Settings.ChargeTypeId.HasValue &&
request.Settings.ChargeTypeId.Value == ChargeTypes.Account.Id)
{
var accountChargeDetail = _accountChargeDao.FindByAccountNumber(request.Settings.AccountNumber);
if (accountChargeDetail.UseCardOnFileForPayment)
{
if (isFromWebApp)
{
// Charge account cannot support prepaid orders
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
_resources.Get("CannotCreateOrderChargeAccountNotSupportedOnWeb", request.ClientLanguageCode));
}
if (_paymentService.IsPayPal(account.Id))
{
chargeTypeOverride = ChargeTypes.PayPal.Display;
request.Settings.ChargeTypeId = ChargeTypes.PayPal.Id;
}
else
{
chargeTypeOverride = ChargeTypes.CardOnFile.Display;
request.Settings.ChargeTypeId = ChargeTypes.CardOnFile.Id;
}
isChargeAccountPaymentWithCardOnFile = true;
}
ValidateChargeAccountAnswers(request.Settings.AccountNumber, request.Settings.CustomerNumber, request.QuestionsAndAnswers, request.ClientLanguageCode, createReportOrder);
if (isChargeAccountPaymentWithCardOnFile)
{
ValidatePayment(companyKey, request, orderId, account, isFutureBooking, request.Estimate.Price, bookingFees, false, createReportOrder);
}
prompts = request.QuestionsAndAnswers.Select(q => q.Answer).ToArray();
promptsLength = request.QuestionsAndAnswers.Select(q => q.MaxLength).ToArray();
}
return(new ChargeAccountValidationResult
{
Prompts = prompts,
PromptsLength = promptsLength,
ChargeTypeKeyOverride = chargeTypeOverride,
IsChargeAccountPaymentWithCardOnFile = isChargeAccountPaymentWithCardOnFile
});
}
protected void ValidateProvider(CreateOrderRequest request, ReferenceData referenceData, bool isInExternalMarket, CreateReportOrder createReportOrder)
{
// Provider is optional for home market
// But if a provider is specified, it must match with one of the ReferenceData values
if (!isInExternalMarket &&
request.Settings.ProviderId.HasValue &&
referenceData.CompaniesList.None(c => c.Id == request.Settings.ProviderId.Value))
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_InvalidProvider,
GetCreateOrderServiceErrorMessage(ErrorCode.CreateOrder_InvalidProvider, request.ClientLanguageCode));
}
}
protected CreateOrder BuildCreateOrderCommand(CreateOrderRequest request, AccountDetail account, CreateReportOrder createReportOrder)
{
_logger.LogMessage("Create order request : " + request);
if (request.Settings.Country == null || !request.Settings.Country.Code.HasValueTrimmed())
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
string.Format(_resources.Get("PhoneNumberCountryNotProvided", request.ClientLanguageCode)));
}
var countryCode = CountryCode.GetCountryCodeByIndex(CountryCode.GetCountryCodeIndexByCountryISOCode(request.Settings.Country));
if (PhoneHelper.IsPossibleNumber(countryCode, request.Settings.Phone))
{
request.Settings.Phone = PhoneHelper.GetDigitsFromPhoneNumber(request.Settings.Phone);
}
else
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable,
string.Format(_resources.Get("PhoneNumberFormat", request.ClientLanguageCode), countryCode.GetPhoneExample()));
}
// TODO MKTAXI-3576: Find a better way to do this...
var isFromWebApp = request.FromWebApp;
if (!isFromWebApp)
{
ValidateAppVersion(request.ClientLanguageCode, createReportOrder);
}
// Find market
var marketSettings = _taxiHailNetworkServiceClient.GetCompanyMarketSettings(request.PickupAddress.Latitude, request.PickupAddress.Longitude);
var market = marketSettings.Market.HasValue() ? marketSettings.Market : null;
createReportOrder.Market = market;
var isFutureBooking = IsFutureBooking(request.PickupDate, marketSettings);
if (!marketSettings.EnableFutureBooking && isFutureBooking)
{
// future booking not allowed
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_FutureBookingNotAllowed", request.ClientLanguageCode));
}
BestAvailableCompany bestAvailableCompany;
if (request.OrderCompanyKey.HasValue() || request.OrderFleetId.HasValue)
{
// For API user, it's possible to manually specify which company to dispatch to by using a fleet id
bestAvailableCompany = _taxiHailNetworkHelper.FindSpecificCompany(market, createReportOrder, request.OrderCompanyKey, request.OrderFleetId, request.PickupAddress.Latitude, request.PickupAddress.Longitude);
}
else
{
bestAvailableCompany = _taxiHailNetworkHelper.FindBestAvailableCompany(marketSettings, request.PickupAddress.Latitude, request.PickupAddress.Longitude, isFutureBooking);
}
_logger.LogMessage("Best available company determined: {0}, in {1}",
bestAvailableCompany.CompanyKey.HasValue() ? bestAvailableCompany.CompanyKey : "local company",
market.HasValue() ? market : "local market");
createReportOrder.CompanyKey = bestAvailableCompany.CompanyKey;
createReportOrder.CompanyName = bestAvailableCompany.CompanyName;
if (market.HasValue())
{
if (!bestAvailableCompany.CompanyKey.HasValue())
{
// No companies available that are desserving this region for the company
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, _resources.Get("CannotCreateOrder_NoCompanies", request.ClientLanguageCode));
}
_taxiHailNetworkHelper.UpdateVehicleTypeFromMarketData(request.Settings, bestAvailableCompany.CompanyKey);
var isConfiguredForCmtPayment = _taxiHailNetworkHelper.FetchCompanyPaymentSettings(bestAvailableCompany.CompanyKey);
if (!isConfiguredForCmtPayment)
{
// Only companies configured for CMT payment can support CoF orders outside of home market
request.Settings.ChargeTypeId = ChargeTypes.PaymentInCar.Id;
}
if (marketSettings.DisableOutOfAppPayment && request.Settings.ChargeTypeId == ChargeTypes.PaymentInCar.Id)
{
// No payment method available since we can't pay in car
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_NoChargeType, _resources.Get("CannotCreateOrder_NoChargeType", request.ClientLanguageCode));
}
}
var isPaypal = request.Settings.ChargeTypeId == ChargeTypes.PayPal.Id;
var isBraintree = (request.Settings.ChargeTypeId == ChargeTypes.CardOnFile.Id) && (_serverSettings.GetPaymentSettings().PaymentMode == PaymentMethod.Braintree);
var isPrepaid = isFromWebApp && (isPaypal || isBraintree);
createReportOrder.IsPrepaid = isPrepaid;
account.IBSAccountId = CreateIbsAccountIfNeeded(account, bestAvailableCompany.CompanyKey);
var pickupDate = request.PickupDate ?? GetCurrentOffsetedTime(bestAvailableCompany.CompanyKey);
createReportOrder.PickupDate = pickupDate;
// User can still create future order, but we allow only one active Book now order.
if (!isFutureBooking)
{
var pendingOrderId = GetPendingOrder();
// We don't allow order creation if there's already an order scheduled
if (!_serverSettings.ServerData.AllowSimultaneousAppOrders &&
pendingOrderId != null &&
!isFromWebApp)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_PendingOrder, pendingOrderId.ToString());
}
}
var rule = _ruleCalculator.GetActiveDisableFor(
isFutureBooking,
pickupDate,
() =>
_ibsServiceProvider.StaticData(bestAvailableCompany.CompanyKey)
.GetZoneByCoordinate(
request.Settings.ProviderId,
request.PickupAddress.Latitude,
request.PickupAddress.Longitude),
() => request.DropOffAddress != null
? _ibsServiceProvider.StaticData(bestAvailableCompany.CompanyKey)
.GetZoneByCoordinate(
request.Settings.ProviderId,
request.DropOffAddress.Latitude,
request.DropOffAddress.Longitude)
: null,
market, new Position(request.PickupAddress.Latitude, request.PickupAddress.Longitude));
if (rule != null)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, rule.Message);
}
// We need to validate the rules of the roaming market.
if (market.HasValue())
{
// External market, query company site directly to validate their rules
var orderServiceClient = new RoamingValidationServiceClient(bestAvailableCompany.CompanyKey, _serverSettings.ServerData.Target);
_logger.LogMessage(string.Format("Validating rules for company in external market... Target: {0}, Server: {1}", _serverSettings.ServerData.Target, orderServiceClient.Url));
var validationResult = orderServiceClient.ValidateOrder(request, true);
if (validationResult.HasError)
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_RuleDisable, validationResult.Message);
}
}
if (Params.Get(request.Settings.Name, request.Settings.Phone).Any(p => p.IsNullOrEmpty()))
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_SettingsRequired);
}
var referenceData = (ReferenceData)_referenceDataService.Get(new ReferenceDataRequest {
CompanyKey = bestAvailableCompany.CompanyKey
});
request.PickupDate = pickupDate;
request.Settings.Passengers = request.Settings.Passengers <= 0
? 1
: request.Settings.Passengers;
if (_serverSettings.ServerData.Direction.NeedAValidTarif &&
(!request.Estimate.Price.HasValue || request.Estimate.Price == 0))
{
ThrowAndLogException(createReportOrder, ErrorCode.CreateOrder_NoFareEstimateAvailable,
GetCreateOrderServiceErrorMessage(ErrorCode.CreateOrder_NoFareEstimateAvailable, request.ClientLanguageCode));
}
// IBS provider validation
ValidateProvider(request, referenceData, market.HasValue(), createReportOrder);
// Map the command to obtain a OrderId (web doesn't prepopulate it in the request)
var orderCommand = Mapper.Map <Commands.CreateOrder>(request);
_logger.LogMessage("MarketSettings for order {0}: {1}", orderCommand.OrderId, marketSettings.ToJson());
var marketFees = _feesDao.GetMarketFees(market);
orderCommand.BookingFees = marketFees != null ? marketFees.Booking : 0;
createReportOrder.BookingFees = orderCommand.BookingFees;
createReportOrder.AssignVehicleId = orderCommand.AssignVehicleId;
// Promo code validation
var promotionId = ValidatePromotion(bestAvailableCompany.CompanyKey, request.PromoCode, request.Settings.ChargeTypeId, account.Id, pickupDate, isFutureBooking, request.ClientLanguageCode, createReportOrder);
// Charge account validation
var accountValidationResult = ValidateChargeAccountIfNecessary(bestAvailableCompany.CompanyKey, request, orderCommand.OrderId, account, isFutureBooking, isFromWebApp, orderCommand.BookingFees, createReportOrder);
createReportOrder.IsChargeAccountPaymentWithCardOnFile = accountValidationResult.IsChargeAccountPaymentWithCardOnFile;
// if ChargeAccount uses payment with card on file, payment validation was already done
if (!accountValidationResult.IsChargeAccountPaymentWithCardOnFile)
{
// Payment method validation
ValidatePayment(bestAvailableCompany.CompanyKey, request, orderCommand.OrderId, account, isFutureBooking, request.Estimate.Price, orderCommand.BookingFees, isPrepaid, createReportOrder);
}
var chargeTypeIbs = string.Empty;
var chargeTypeEmail = string.Empty;
var chargeTypeKey = ChargeTypes.GetList()
.Where(x => x.Id == request.Settings.ChargeTypeId)
.Select(x => x.Display)
.FirstOrDefault();
chargeTypeKey = accountValidationResult.ChargeTypeKeyOverride ?? chargeTypeKey;
if (chargeTypeKey != null)
{
// this must be localized with the priceformat to be localized in the language of the company
// because it is sent to the driver
chargeTypeIbs = _resources.Get(chargeTypeKey, _serverSettings.ServerData.PriceFormat);
chargeTypeEmail = _resources.Get(chargeTypeKey, request.ClientLanguageCode);
}
// Get Vehicle Type from reference data
var vehicleType = referenceData.VehiclesList
.Where(x => x.Id == request.Settings.VehicleTypeId)
.Select(x => x.Display)
.FirstOrDefault();
// Use address alias if present.
var addressAlias = request.PickupAddress.FriendlyName.HasValueTrimmed()
? request.PickupAddress.FriendlyName
: request.PickupAddress.BuildingName;
var ibsInformationNote = IbsHelper.BuildNote(
_serverSettings.ServerData.IBS.NoteTemplate,
chargeTypeIbs,
request.Note,
addressAlias,
request.Settings.LargeBags,
_serverSettings.ServerData.IBS.HideChargeTypeInUserNote);
var fare = FareHelper.GetFareFromEstimate(request.Estimate);
orderCommand.AccountId = account.Id;
orderCommand.UserAgent = Request.UserAgent;
orderCommand.ClientVersion = Request.Headers.Get("ClientVersion");
orderCommand.IsChargeAccountPaymentWithCardOnFile = accountValidationResult.IsChargeAccountPaymentWithCardOnFile;
orderCommand.CompanyKey = bestAvailableCompany.CompanyKey;
orderCommand.CompanyName = bestAvailableCompany.CompanyName;
orderCommand.CompanyFleetId = bestAvailableCompany.FleetId;
orderCommand.Market = market;
orderCommand.IsPrepaid = isPrepaid;
orderCommand.Settings.ChargeType = chargeTypeIbs;
orderCommand.Settings.VehicleType = vehicleType;
orderCommand.IbsAccountId = account.IBSAccountId.Value;
orderCommand.ReferenceDataCompanyList = referenceData.CompaniesList.ToArray();
orderCommand.IbsInformationNote = ibsInformationNote;
orderCommand.Fare = fare;
orderCommand.Prompts = accountValidationResult.Prompts;
orderCommand.PromptsLength = accountValidationResult.PromptsLength;
orderCommand.PromotionId = promotionId;
orderCommand.ChargeTypeEmail = chargeTypeEmail;
orderCommand.OriginatingIpAddress = createReportOrder.OriginatingIpAddress = request.CustomerIpAddress;
orderCommand.KountSessionId = createReportOrder.OriginatingIpAddress = request.KountSessionId;
orderCommand.IsFutureBooking = createReportOrder.IsFutureBooking = isFutureBooking;
orderCommand.AssignVehicleId = createReportOrder.AssignVehicleId;
Debug.Assert(request.PickupDate != null, "request.PickupDate != null");
return(orderCommand);
}
