public new void TestFixtureSetup()
{
base.TestFixtureSetup();
var container = UnityServiceLocator.Instance;
_taxiHailNetworkServiceImplementation = container.Registrations
.FirstOrDefault(x => x.RegisteredType == typeof(ITaxiHailNetworkServiceClient))
.MappedToType;
_orderId = Guid.NewGuid();
var authTask = new AuthServiceClient(BaseUrl, SessionId, new DummyPackageInfo(), null, null).Authenticate(TestAccount.Email, TestAccountPassword);
authTask.Wait();
var auth = authTask.Result;
SessionId = auth.SessionId;
var sut = new OrderServiceClient(BaseUrl, SessionId, new DummyPackageInfo(), null, null);
var order = new CreateOrderRequest
{
Id = _orderId,
PickupAddress = TestAddresses.GetAddress1(),
DropOffAddress = TestAddresses.GetAddress2(),
Estimate = new RideEstimate
{
Price = 10,
Distance = 3
},
Settings = new BookingSettings
{
ChargeTypeId = ChargeTypes.PaymentInCar.Id,
VehicleTypeId = 1,
ProviderId = Provider.ApcuriumIbsProviderId,
Phone = "5145551212",
Country = new CountryISOCode("CA"),
Passengers = 6,
NumberOfTaxi = 1,
Name = "Joe Smith",
LargeBags = 1
},
ClientLanguageCode = SupportedLanguages.fr.ToString()
};
sut.CreateOrder(order).Wait();
// Wait for IBS order Id to be assigned
Thread.Sleep(10000);
}
public async Task Sandbox_Payment_CanCancel()
{
//This is an integration test, it requires user interaction to complete.
//You need to set the environment variable Yort_Laybuy_InStore_TestMobileNumber to a valid mobile phone number.
//It will create an order in the Laybuy sandbox environment
//Poll until the order reaches success or declined status (requires user to login to sandbox portal and accept payment)
//Refund the order in full
var client = CreateClient();
// Create the 'order'
var createRequest = new CreateOrderRequest()
{
Amount = 10,
MerchantReference = System.Guid.NewGuid().ToString(),
Customer = new RequestLaybuyCustomer()
{
Phone = Environment.GetEnvironmentVariable("Yort_Laybuy_InStore_TestMobileNumber")
}
};
System.Diagnostics.Trace.WriteLine("Merchant Ref: " + createRequest.MerchantReference);
var result = await client.Create(createRequest).ConfigureAwait(false);
Assert.IsNotNull(result);
Assert.AreEqual(result.Result, LaybuyStatus.Success);
Assert.IsFalse(String.IsNullOrWhiteSpace(result.Token));
await Task.Delay(2000).ConfigureAwait(false);
var response = await client.Cancel(new CancelOrderRequest()
{
Token = result.Token
}).ConfigureAwait(false);
Assert.IsNotNull(response);
Assert.AreEqual(response.Result, LaybuyStatus.Success);
await Task.Delay(2000).ConfigureAwait(false);
var statusResponse = await client.GetOrderStatus(new OrderStatusRequest()
{
MerchantReference = createRequest.MerchantReference
}).ConfigureAwait(false);
Assert.IsNotNull(statusResponse);
Assert.AreEqual(statusResponse.Status, LaybuyOrderStatus.Cancelled);
}
public async Task <string> Sell(string market, double quantity, double rate)
{
var request = new CreateOrderRequest
{
Symbol = market,
Quantity = (decimal)quantity,
Price = rate,
Type = BinanceExchange.API.Enums.OrderType.Limit,
Side = BinanceExchange.API.Enums.OrderSide.Sell
};
var result = await _client.CreateOrder(request);
return(result.ClientOrderId);
}
public void Handle(CreateOrderRequest command)
{
OrderAggregate order = AggregateFactory.Create <OrderAggregate>();
order.AddCustomerDetail(command.CustomerDetail);
order.AddOrderLineItems(command.OrderLines);
using (IUnitOfWork uow = this.CreateUnitOfWork <OrderAggregate>())
{
IOrderRepository repository = IoC.Container.Resolve <IOrderRepository>(uow);
repository.Add(order);
uow.Commit();
order.AddEvent(new OnOrderCreated(order.Id));
}
order.PublishEvents();
}
public static CreateOrderRequest AsRequest(this AddOrderWebRequest request)
{
var result = new CreateOrderRequest
{
RecipientName = request.RecipientName,
RecipientEmail = request.RecipientEmail,
SenderName = request.SenderName,
SenderEmail = request.SenderEmail,
Dedication = request.Dedication,
Voucher = request.Voucher,
OrderDate = request.OrderDate
};
return(result);
}
public async Task <ActionResult <string> > Create([FromBody] CreateOrderRequest request)
{
await orderRepository.AddAsync(new Order
{
//Authorize yok ama olsaydı böyle yapabilirdik (CurrentUserId adında prop oluştururduk her yerden erişebilecek şekilde => HttpContext.User.Claims.FirstOrDefault(x => x.Type == "UserId").Value.ToString() )
//CustomerId = CurrentUserId
CustomerId = request.CustomerId,
ImageUrl = request.ImageUrl,
Price = request.Price,
Quantity = request.Quantity,
Status = "Oluşturuldu"
});
return(Ok("Tabrikler siparişiniz başarıyla oluşturuldu!"));
}
public static CreateOrderRequest Create(MundiPaggOrder mundiPaggOrder)
{
CreateCustomerRequest customer = mundiPaggOrder.Customer;
List <CreateOrderItemRequest> items = mundiPaggOrder.Items.Cast <CreateOrderItemRequest>().ToList();
List <CreatePaymentRequest> payments = mundiPaggOrder.Payments.Cast <CreatePaymentRequest>().ToList();
var order = new CreateOrderRequest()
{
Items = items,
Customer = customer,
Payments = payments
};
return(order);
}
public void Construct()
{
var action = new CreateOrderRequest("test.com");
Assert.Equal(new Identifier("dns", "test.com"), action.Identifiers[0]);
Assert.Equal(@"{
""identifiers"": [
{
""type"": ""dns"",
""value"": ""test.com""
}
]
}", JsonObject.FromObject(action).ToString());
}
public async Task ZipClient_CanGetOrderStatus()
{
using (var client = CreateTestClient())
{
#region Create an order to get the status of
var request = new CreateOrderRequest()
{
TerminalId = "2531",
Order = new ZipOrder()
{
Amount = 10.5M,
CustomerApprovalCode = "AA05",
MerchantReference = System.Guid.NewGuid().ToString(),
Operator = "Test",
PaymentFlow = ZipPaymentFlow.Payment
}
};
var createOrderResult = await client.CreateOrderAsync(request);
Assert.IsNotNull(createOrderResult);
#endregion
var statusResponse = await client.GetOrderStatusAsync(new OrderStatusRequest()
{
OrderId = createOrderResult.OrderId
});
Assert.IsNotNull(statusResponse);
while (!ZipOrderStatus.IsTerminalStatus(statusResponse.Status))
{
System.Diagnostics.Trace.WriteLine($"Order {statusResponse.OrderNumber} status is {statusResponse.Status}");
await Task.Delay(1000);
statusResponse = await client.GetOrderStatusAsync(new OrderStatusRequest()
{
OrderId = createOrderResult.OrderId
});
}
Assert.IsNotNull(statusResponse);
Assert.AreEqual(ZipOrderStatus.Complete, statusResponse.Status);
}
}
static async Task Main(string[] args)
{
// Creating Request with Order data, that we want to create
var createOrderRequest = new CreateOrderRequest
{
Order = new Order
{
Value = 15.5,
CustomerName = "Sample Customer Name",
Items =
{
new OrderItem
{
Name = "First Item"
},
new OrderItem
{
Name = "Second Item"
}
}
}
};
// Fetching gRPC Service URL from appsettings.json
var serviceUrl = Configuration.GetValue <string>("OrderingServiceUrl");
// Creating channel and client
using var channel = GrpcChannel.ForAddress(serviceUrl);
var client = new Ordering.OrderingClient(channel);
Info("Creating an Order ...");
// Invoking the client to create the Order and getting response from the Service
var createOrderResponse = await client.CreateOrderAsync(createOrderRequest);
Info($"Order created | OrderId: {createOrderResponse.OrderId}");
// Creating Request passing Id of created Order to fetch its data
var orderRequest = new GetOrderByIdRequest
{
OrderId = createOrderResponse.OrderId
};
Info($"Getting Order | OrderId: {orderRequest.OrderId}");
// Invoking the client to fetch created Order (with its Ids generated server-side)
var orderResponse = await client.GetOrderByIdAsync(orderRequest);
// Printing Order data
Info($"Order found | {orderResponse.Order}");
}
public async void when_creating_an_order_with_a_new_pickup_address()
{
//Arrange
var newAccount = await CreateAndAuthenticateTestAccount();
var orderService = new OrderServiceClient(BaseUrl, SessionId, new DummyPackageInfo(), null, null);
//Act
var order = new CreateOrderRequest
{
Id = Guid.NewGuid(),
PickupAddress = TestAddresses.GetAddress1(),
PickupDate = DateTime.Now,
DropOffAddress = TestAddresses.GetAddress2(),
Estimate = new RideEstimate
{
Distance = 3,
Price = 10
},
Settings = new BookingSettings
{
ChargeTypeId = ChargeTypes.PaymentInCar.Id,
VehicleTypeId = 7,
ProviderId = Provider.ApcuriumIbsProviderId,
Phone = "5145551212",
Country = new CountryISOCode("CA"),
Passengers = 6,
NumberOfTaxi = 1,
Name = "Joe Smith"
},
ClientLanguageCode = "en"
};
await orderService.CreateOrder(order);
//Assert
var sut = new AccountServiceClient(BaseUrl, SessionId, new DummyPackageInfo(), null, null);
var addresses = await sut.GetHistoryAddresses(newAccount.Id);
Assert.AreEqual(1, addresses.Count());
var address = addresses.Single();
Assert.AreEqual(order.PickupAddress.Apartment, address.Apartment);
Assert.AreEqual(order.PickupAddress.RingCode, address.RingCode);
Assert.AreEqual(order.PickupAddress.FullAddress, address.FullAddress);
Assert.AreEqual(order.PickupAddress.BuildingName, address.BuildingName);
Assert.AreEqual(order.PickupAddress.Latitude, address.Latitude);
Assert.AreEqual(order.PickupAddress.Longitude, address.Longitude);
}
private async Task <string> CreateOrder(Action <CreateOrderRequest> update)
{
var sut = new OrderServiceClient(BaseUrl, SessionId, new DummyPackageInfo(), null, null);
var order = new CreateOrderRequest
{
Id = Guid.NewGuid(),
PickupAddress = TestAddresses.GetAddress1(),
PickupDate = null,
DropOffAddress = TestAddresses.GetAddress2(),
Estimate = new RideEstimate
{
Price = 10,
Distance = 3
},
Settings = new BookingSettings
{
ChargeTypeId = ChargeTypes.PaymentInCar.Id,
VehicleTypeId = 1,
ProviderId = Provider.ApcuriumIbsProviderId,
Phone = "5145551212",
Passengers = 6,
NumberOfTaxi = 1,
Name = "Joe Smith",
Country = new CountryISOCode("CA")
},
ClientLanguageCode = SupportedLanguages.en.ToString()
};
if (update != null)
{
update(order);
}
try
{
await sut.CreateOrder(order);
}
catch (WebServiceException wEx)
{
return(wEx.ErrorMessage);
}
catch (Exception ex)
{
return(ex.Message);
}
return(null);
}
public int EstimateTotalInCents(CreateOrderRequest orderRequest)
{
var subtotalInCents = orderRequest.Order.LineItems.Sum(x => Convert.ToInt32(x.BasePriceMoney.Amount * Int32.Parse(x.Quantity)));
var tax = orderRequest.Order.Taxes
.Where(x => x.Type == "ADDITIVE" &&
!EXCLUDE.Any(y => x.Name.ToLower().Contains(y)))
.Sum(x => Decimal.Parse(x.Percentage));
var taxPlusTotal = 1 + tax / 100;
var totalInCents = subtotalInCents * taxPlusTotal;
var roundedTotalInCents = Math.Round(totalInCents);
var intTotal = Convert.ToInt32(roundedTotalInCents);
return(intTotal);
}
public override OpenOrderEntryModel RequestNewOrder(CreateOrderRequestBase orderNewRequest)
{
var order = new CreateOrderRequest(this)
{
Volume = orderNewRequest.Amount,
Price = DecimalConverter.Convert(orderNewRequest.Price),
OrderType = orderNewRequest.OrderType.Value,
Type = orderNewRequest.Side.Value,
Pair = orderNewRequest.Pair,
Validate = orderNewRequest.Validate,
};
var response = order.Request <CreateOrderResponse>();
return(OnCreateOrder(response, response));
}
// [Fact]
public async Task C()
{
var client = new AcmeClient(
privateKey: RSA.Create(RSAPrivateKey.Decode(TestData.PrivateRSA256KeyText)),
accountUrl: "https://acme-staging-v02.api.letsencrypt.org/acme/acct/5363173",
directoryUrl: "https://acme-staging-v02.api.letsencrypt.org/directory"
);
var request = new CreateOrderRequest(new[] {
new Identifier("dns", "test.accelerator.net")
}, null, null);
var order = await client.CreateOrderAsync(request);
throw new Exception(JsonObject.FromObject(new { order, order.Url }).ToString());
}
public async Task <CreateOrderResponse> CreateOrderAsync(CreateOrderRequest request)
{
var queryString = HttpHelper.QueryString(new Dictionary <string, string>
{
{ "symbol", request.Pair },
{ "side", request.TradeType.ToString().ToUpper() },
{ "type", request.OrderType.ToString().ToUpper() },
{ "quantity", request.Amount.ToString(CultureInfo.InvariantCulture) },
{ "price", request.Rate.ToString(CultureInfo.InvariantCulture) },
{ "timeInForce", "GTC" },
{ "timestamp", DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString() }
}, true);
var content = await MakePrivateCallAsync(HttpMethod.Post, "order", queryString);
return(new CreateOrderResponse((long)content.orderId));
}
public override async Task <CreateOrderReply> CreateOrder(CreateOrderRequest request, ServerCallContext context)
{
var orderId = Guid.NewGuid().ToString();
await this._shippings.SendOrderAsync(new SendOrderRequest
{
ProductId = request.ProductId,
Quantity = request.Quantity,
Address = request.Address
});
this._logger.LogInformation($"Created order {orderId} with productId={request.ProductId}, quantity={request.Quantity}, address={request.Address}");
return(new CreateOrderReply {
OrderId = orderId
});
}
public async Task <IActionResult> CreateOrder(CreateOrderRequest request)
{
CreateOrderCommand command = _mapper.Map <CreateOrderCommand>(request);
_logger.LogInformation("Begin to Create Order");
LibMediator.Command.CommandResult result = await _mediator.Send(command);
if (result.Succeed)
{
_logger.LogInformation("Order Created");
return(NoContent());
}
_logger.LogWarning("Create Order Failed");
return(BadRequest());
}
public static OrderEntity AsEntity(this CreateOrderRequest request)
{
var result = new OrderEntity
{
RecipientName = request.RecipientName,
RecipientEmail = request.RecipientEmail,
SenderName = request.SenderName,
SenderEmail = request.SenderEmail,
Dedication = request.Dedication,
Voucher = request.Voucher,
OrderDate = request.OrderDate
//// Assign all necessary fields e.g. when new fields are introduced
};
return(result);
}
public async Task <CreateOrderResponse> CreateOrder(CreateOrderRequest request)
{
var orderItems = request.CartItems.Select(item => new OrderItem(
item.OfferId, item.OfferName, item.Quantity, item.PricePerItem, item.ImageUri)).ToList();
var order = new Order(request.UserId, request.SellerId, orderItems);
_orderRepository.Add(order);
await _orderRepository.UnitOfWork.SaveChangesAndDispatchDomainEventsAsync();
var orderStartedIntegrationEvent = new OrderStartedIntegrationEvent
{
OrderId = order.Id,
OrderItems = order.OrderItems.Select(orderItem => new OrderItemDto
{
OfferId = orderItem.OfferId,
Quantity = orderItem.Quantity
}).ToList()
};
await _eventBus.PublishAsync(orderStartedIntegrationEvent);
_logger.LogInformation($"Integration event {nameof(OrderStartedIntegrationEvent)} published",
"EventId".ToKvp(orderStartedIntegrationEvent.Id),
"OfferIds".ToKvp(string.Join(",", orderStartedIntegrationEvent.OrderItems.Select(x => x.OfferId))));
var notificationIntegrationEvent = new NotificationIntegrationEvent
{
UserId = order.SellerId,
Code = NotificationCodes.OrderStarted,
Message = "Order started",
Metadata = new Dictionary <string, string>
{
{ "OrderId", order.Id.ToString() },
{ "BuyerId", order.BuyerId.ToString() },
{ "OfferIds", string.Join(",", request.CartItems.Select(x => x.OfferId)) }
}
};
await _eventBus.PublishAsync(notificationIntegrationEvent);
_logger.LogInformation($"Published {nameof(NotificationIntegrationEvent)}",
"EventId".ToKvp(orderStartedIntegrationEvent.Id),
"PublishedEventId".ToKvp(notificationIntegrationEvent.Id),
"NotifiedUserId".ToKvp(notificationIntegrationEvent.UserId));
return(new CreateOrderResponse {
OrderId = order.Id
});
}
public ActionResult PlaceOrder(FormCollection collection)
{
CreateOrderRequest request = new CreateOrderRequest();
request.BasketId = base.GetBasketId();
request.CustomerIdentityToken = _formsAuthentication.GetAuthorisationToken();
request.DeliveryId = int.Parse(collection[FormDataKeys.DeliveryAddress.ToString()]);
CreateOrderResponse response = _orderService.CreateOrder(request);
_cookieStorageService.Save(CookieDataKeys.BasketItems.ToString(), "0", DateTime.Now.AddDays(1));
_cookieStorageService.Save(CookieDataKeys.BasketTotal.ToString(), "0", DateTime.Now.AddDays(1));
return(RedirectToAction("CreatePaymentFor", "Payment", new { orderId = response.Order.Id }));
}
public OrderValidationResult ValidateOrder(CreateOrderRequest orderRequest, bool forError = false)
{
try
{
var req = string.Format("api/account/orders/validate/" + forError);
return(_client.Post(req, orderRequest)
.Deserialize <OrderValidationResult>()
.Result);
}
catch (Exception)
{
// Error while contacting external rule server. Don't validate rules.
return(new OrderValidationResult {
HasError = false
});
}
}
public override OpenOrderEntryModel RequestNewOrder(CreateOrderRequestBase orderNewRequest)
{
var order = new CreateOrderRequest(this)
{
Amount = DecimalConverter.Convert(orderNewRequest.Amount),
Price = DecimalConverter.Convert(orderNewRequest.Price),
IsHidden = orderNewRequest.IsHidden,
Exchange = orderNewRequest.ExchangeType.Value,
Type = orderNewRequest.OrderType.Value,
Side = orderNewRequest.Side.Value,
Symbol = orderNewRequest.Pair
};
var response = order.Request <CreateOrderResponse>();
return(OnCreateOrder(response, response));
}
public async Task <CreateOrderResponse> CreateOrderAsync([FromBody] CreateOrderRequest model)
{
try
{
string orderId = await _internalOrderService.CreateOrderAsync(model.WalletId, model.AssetPair,
model.Type == OrderType.Sell?LimitOrderType.Sell : LimitOrderType.Buy,
model.Price, model.Volume, model.FullExecution);
return(new CreateOrderResponse {
OrderId = orderId
});
}
catch (InvalidOperationException exception)
{
throw new ValidationApiException(exception.Message);
}
}
public string CreateOrder(CreateOrderRequest createOrderRequest)
{
var client = new RestClient(_baseUrl);
var request = new RestRequest("api/order", Method.POST);
request.AddHeader("Accept", "application/json");
string jsonObject = JsonConvert.SerializeObject(createOrderRequest, Formatting.Indented, jsonSerializerSettings);
request.AddParameter("application/json", jsonObject, ParameterType.RequestBody);
var response = client.Execute(request);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(response.Content);
}
return($"Order created; product {createOrderRequest.ProductCode}, quantity {createOrderRequest.Quantity}");
}
public override async Task <CreateOrderResponse> CreateOrder(CreateOrderRequest request, ServerCallContext context)
{
request.Order.OrderUuid = Guid.NewGuid().ToString();
await using var connection = new NpgsqlConnection(_connectionString);
await connection.ExecuteAsync(InsertOrderSql, new
{
OrderUuid = Guid.Parse(request.Order.OrderUuid),
ProductUuid = Guid.Parse(request.Order.ProductUuid),
DeliveryUuid = Guid.Parse(request.Order.DeliveryUuid),
Count = (int)request.Order.Count,
});
return(new CreateOrderResponse
{
Order = request.Order,
});
}
public void CreateOrder(CreateOrderRequest orderDto)
{
ValidatePhoneNumber(orderDto.ReceiverPhoneNumber);
ValidatePostamatNumber(orderDto.PostamatNumber);
ValidateGoods(orderDto.Goods);
var order = new Order(orderDto.PostamatNumber)
{
Goods = orderDto.Goods,
OrderNumber = orderDto.OrderNumber,
Price = orderDto.Price,
ReceiverFullName = orderDto.ReceiverFullName,
ReceiverPhoneNumber = orderDto.ReceiverPhoneNumber
};
_ordersRepository.Add(order);
}
public async ValueTask AddOrder(CreateOrderRequest request)
{
Console.WriteLine($"Received order placed at {request.OrderedAt.ToLongDateString()}");
foreach (var orderLine in request.OrderLines)
{
Console.WriteLine($"Received {orderLine.ProductId}");
}
using var channel = GrpcChannel.ForAddress("https://localhost:5003");
var financialService = channel.CreateGrpcService <IFinancialService>();
await financialService.AddInvoice(new AddInvoiceRequest
{
Amount = request.OrderLines.Sum(line => line.Price *line.Quantity),
CustomerId = request.CustomerId
});
}
/// <summary>
/// Sends Creating Order request to Webmoney merchant API
/// </summary>
/// <param name="model">Create Order Request model</param>
/// <returns>Respones Handler</returns>
public WMResponseHandler <CreateOrderResponse> CreateOrder(CreateOrderRequest model)
{
var httpRequest = HttpContext.Current.Request;
string url = this.CreateURL("create-order");
var request = this.CreateRequest(url);
model.ClientIP = NetHelper.GetClientIPAddress();
model.UserAgent = httpRequest.UserAgent;
model.HashChecksum(this);
string jsonText = JsonConvert.SerializeObject(model);
string jsonResponse = NetHelper.HttpRequest(request, jsonText);
var response = WMResponseHandler <CreateOrderResponse> .Load(jsonResponse);
return(response);
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
{
try
{
var orderApiUrl = _configuration.GetValue <string>(ORDERS_API_URL_SETTING_KEY).Trim('/');
var url = $"http://{orderApiUrl}/api/v1.0/orders";
var httpClient = new HttpClient();
var response = await httpClient.PostAsync(url, new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json"));
return(Ok(await response.Content.ReadAsStringAsync()));
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex);
throw;
}
}
// Creating an order
private CreateOrderRequest Request_CreateOrder()
{
CreateOrderRequest request = new CreateOrderRequest();
request.CustomerID = Identity.Current.CustomerID;
request.CurrencyCode = Shopping.Configuration.CurrencyCode;
request.WarehouseID = Shopping.Configuration.WarehouseID;
request.PriceType = Shopping.Configuration.PriceTypeID;
request.ShipMethodID = Shopping.PropertyBag.ShipMethodID;
request.OrderDate = DateTime.Now;
request.OrderStatus = OrderStatusType.Incomplete;
request.OrderType = Exigo.WebService.OrderType.APIOrder;
request.FirstName = Shopping.PropertyBag.ShippingFirstName;
request.LastName = Shopping.PropertyBag.ShippingLastName;
request.Address1 = Shopping.PropertyBag.ShippingAddress1;
request.Address2 = Shopping.PropertyBag.ShippingAddress2;
request.City = Shopping.PropertyBag.ShippingCity;
request.State = Shopping.PropertyBag.ShippingState;
request.Zip = Shopping.PropertyBag.ShippingZip;
request.Country = Shopping.PropertyBag.ShippingCountry;
request.Phone = Shopping.PropertyBag.Phone;
request.Email = Shopping.PropertyBag.Email;
request.Details = GetOrderDetails();
return request;
}
private CreateOrderRequest Request_PlaceGPRRorder()
{
var NotesInLongForm = new StringBuilder();
NotesInLongForm.AppendFormat(@"
<table>
<tr>
<td>
Comments: {0}
</td>
</tr>
</table>
"
, Comments
);
CreateOrderRequest request = new CreateOrderRequest();
try
{
// Variables that are required by the API
request.CustomerID = CurrentUser_ID;
request.CurrencyCode = "usd";
request.OrderStatus = OrderStatusType.Shipped;
request.OrderType = OrderType.APIOrder;
request.PriceType = GlobalSettings.Shopping.DefaultPriceTypeID;
request.WarehouseID = 4;
request.ShipMethodID = 15;
request.City = "Orem";
request.State = "UT";
request.Country = "US";
// Add Personal Information
request.FirstName = FirstName;
request.LastName = LastName;
request.Phone = Phone1;
request.Email = Email;
request.Address1 = LikelyAvailable;
request.Address2 = TimeZone;
// Add Notes and the Date of the Order
request.Notes = NotesInLongForm.ToString();
request.OrderDate = DateTime.Now;
//Add Details
List<OrderDetailRequest> details = new List<OrderDetailRequest>();
OrderDetailRequest detail1 = new OrderDetailRequest();
detail1.ItemCode = "GPRR";
detail1.Quantity = 1;
details.Add(detail1);
//Now attach the list to the request
request.Details = details.ToArray();
isValid = true;
}
catch
{
isValid = false;
}
//Send Request to Server and Get Response
var context = ExigoApiContext.CreateWebServiceContext();
CreateOrderResponse res = context.CreateOrder(request);
Response.Write(res.OrderID);
return request;
}
/// <remarks/>
public void CreateOrderAsync(CreateOrderRequest CreateOrderRequest) {
this.CreateOrderAsync(CreateOrderRequest, null);
}
public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
{
order.MustNotBeNull( "order" );
settings.MustNotBeNull( "settings" );
settings.MustContainKey( "customerLanguageCode", "settings" );
settings.MustContainKey( "testMode", "settings" );
PaymentHtmlForm htmlForm = new PaymentHtmlForm();
IPaynovaClient client = GetClient( settings );
Currency currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId );
if ( !Iso4217CurrencyCodes.ContainsKey( currency.IsoCode ) ) {
throw new Exception( "You must specify an ISO 4217 currency code for the " + currency.Name + " currency" );
}
try {
//Create order request
CreateOrderRequest createOrderRequest = new CreateOrderRequest( order.CartNumber, currency.IsoCode, order.TotalPrice.Value.WithVat ) {
Customer = new Customer(),
BillTo = new NameAndAddress(),
ShipTo = new NameAndAddress()
};
#region Customer information
createOrderRequest.Customer.EmailAddress = order.PaymentInformation.Email;
createOrderRequest.Customer.Name.CompanyName = createOrderRequest.BillTo.Name.CompanyName = order.Properties[ settings.ContainsKey( "companyPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "companyPropertyAlias" ] ) ? settings[ "companyPropertyAlias" ] : "company" ];
createOrderRequest.Customer.Name.Title = createOrderRequest.BillTo.Name.Title = order.Properties[ settings.ContainsKey( "titlePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "titlePropertyAlias" ] ) ? settings[ "titlePropertyAlias" ] : "title" ];
createOrderRequest.Customer.Name.FirstName = createOrderRequest.BillTo.Name.FirstName = order.PaymentInformation.FirstName;
createOrderRequest.Customer.Name.MiddleNames = createOrderRequest.BillTo.Name.MiddleNames = order.Properties[ settings.ContainsKey( "middleNamesPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "middleNamesPropertyAlias" ] ) ? settings[ "middleNamesPropertyAlias" ] : "middleNames" ];
createOrderRequest.Customer.Name.LastName = createOrderRequest.BillTo.Name.LastName = order.PaymentInformation.LastName;
createOrderRequest.Customer.Name.Suffix = createOrderRequest.BillTo.Name.Suffix = order.Properties[ settings.ContainsKey( "suffixPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "suffixPropertyAlias" ] ) ? settings[ "suffixPropertyAlias" ] : "suffix" ];
createOrderRequest.Customer.HomeTelephone = order.Properties[ settings.ContainsKey( "homeTelephonePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "homeTelephonePropertyAlias" ] ) ? settings[ "homeTelephonePropertyAlias" ] : "phone" ];
createOrderRequest.Customer.WorkTelephone = order.Properties[ settings.ContainsKey( "workTelephonePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "workTelephonePropertyAlias" ] ) ? settings[ "workTelephonePropertyAlias" ] : "workPhone" ];
createOrderRequest.Customer.MobileTelephone = order.Properties[ settings.ContainsKey( "mobileTelephonePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "mobileTelephonePropertyAlias" ] ) ? settings[ "mobileTelephonePropertyAlias" ] : "mobile" ];
createOrderRequest.BillTo.Address.Street1 = order.Properties[ settings.ContainsKey( "street1PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "street1PropertyAlias" ] ) ? settings[ "street1PropertyAlias" ] : "streetAddress" ];
createOrderRequest.BillTo.Address.Street2 = order.Properties[ settings.ContainsKey( "street2PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "street2PropertyAlias" ] ) ? settings[ "street2PropertyAlias" ] : "streetAddress2" ];
createOrderRequest.BillTo.Address.Street3 = order.Properties[ settings.ContainsKey( "street3PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "street3PropertyAlias" ] ) ? settings[ "street3PropertyAlias" ] : "streetAddress3" ];
createOrderRequest.BillTo.Address.Street4 = order.Properties[ settings.ContainsKey( "street4PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "street4PropertyAlias" ] ) ? settings[ "street4PropertyAlias" ] : "streetAddress4" ];
createOrderRequest.BillTo.Address.City = order.Properties[ settings.ContainsKey( "cityPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "cityPropertyAlias" ] ) ? settings[ "cityPropertyAlias" ] : "city" ];
createOrderRequest.BillTo.Address.PostalCode = order.Properties[ settings.ContainsKey( "postalCodePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "postalCodePropertyAlias" ] ) ? settings[ "postalCodePropertyAlias" ] : "zipCode" ];
if ( order.PaymentInformation.CountryRegionId != null ) {
createOrderRequest.BillTo.Address.RegionCode = CountryRegionService.Instance.Get( order.StoreId, order.PaymentInformation.CountryRegionId.Value ).RegionCode;
}
createOrderRequest.BillTo.Address.CountryCode = CountryService.Instance.Get( order.StoreId, order.PaymentInformation.CountryId ).RegionCode;
createOrderRequest.ShipTo.Name.CompanyName = order.Properties[ settings.ContainsKey( "shipping_companyPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_companyPropertyAlias" ] ) ? settings[ "shipping_companyPropertyAlias" ] : "shipping_company" ];
createOrderRequest.ShipTo.Name.Title = order.Properties[ settings.ContainsKey( "shipping_titlePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_titlePropertyAlias" ] ) ? settings[ "shipping_titlePropertyAlias" ] : "shipping_title" ];
createOrderRequest.ShipTo.Name.FirstName = order.Properties[ settings.ContainsKey( "shipping_firstNamePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_firstNamePropertyAlias" ] ) ? settings[ "shipping_firstNamePropertyAlias" ] : "shipping_firstName" ];
createOrderRequest.ShipTo.Name.MiddleNames = order.Properties[ settings.ContainsKey( "shipping_middleNamesPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_middleNamesPropertyAlias" ] ) ? settings[ "shipping_middleNamesPropertyAlias" ] : "shipping_middleNames" ];
createOrderRequest.ShipTo.Name.LastName = order.Properties[ settings.ContainsKey( "shipping_lastNamePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_lastNamePropertyAlias" ] ) ? settings[ "shipping_lastNamePropertyAlias" ] : "shipping_lastName" ];
createOrderRequest.ShipTo.Name.Suffix = order.Properties[ settings.ContainsKey( "shipping_suffixPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_suffixPropertyAlias" ] ) ? settings[ "shipping_suffixPropertyAlias" ] : "shipping_suffix" ];
createOrderRequest.ShipTo.Address.Street1 = order.Properties[ settings.ContainsKey( "shipping_street1PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_street1PropertyAlias" ] ) ? settings[ "shipping_street1PropertyAlias" ] : "shipping_streetAddress" ];
createOrderRequest.ShipTo.Address.Street2 = order.Properties[ settings.ContainsKey( "shipping_street2PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_street2PropertyAlias" ] ) ? settings[ "shipping_street2PropertyAlias" ] : "shipping_streetAddress2" ];
createOrderRequest.ShipTo.Address.Street3 = order.Properties[ settings.ContainsKey( "shipping_street3PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_street3PropertyAlias" ] ) ? settings[ "shipping_street3PropertyAlias" ] : "shipping_streetAddress3" ];
createOrderRequest.ShipTo.Address.Street4 = order.Properties[ settings.ContainsKey( "shipping_street4PropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_street4PropertyAlias" ] ) ? settings[ "shipping_street4PropertyAlias" ] : "shipping_streetAddress4" ];
createOrderRequest.ShipTo.Address.City = order.Properties[ settings.ContainsKey( "shipping_cityPropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_cityPropertyAlias" ] ) ? settings[ "shipping_cityPropertyAlias" ] : "shipping_city" ];
createOrderRequest.ShipTo.Address.PostalCode = order.Properties[ settings.ContainsKey( "shipping_postalCodePropertyAlias" ) && !string.IsNullOrEmpty( settings[ "shipping_postalCodePropertyAlias" ] ) ? settings[ "shipping_postalCodePropertyAlias" ] : "shipping_zipCode" ];
if ( order.ShipmentInformation.CountryRegionId != null ) {
createOrderRequest.ShipTo.Address.RegionCode = CountryRegionService.Instance.Get( order.StoreId, order.ShipmentInformation.CountryRegionId.Value ).RegionCode;
}
if ( order.ShipmentInformation.CountryId != null ) {
createOrderRequest.ShipTo.Address.CountryCode = CountryService.Instance.Get( order.StoreId, order.ShipmentInformation.CountryId.Value ).RegionCode;
}
#endregion
CreateOrderResponse createOrderResponse = client.CreateOrder( createOrderRequest );
//Initialize payment request
InterfaceOptions interfaceOptions = new InterfaceOptions( InterfaceId.Aero, settings[ "customerLanguageCode" ], new Uri( teaCommerceContinueUrl ), new Uri( teaCommerceCancelUrl ), new Uri( teaCommerceContinueUrl ) );
InitializePaymentRequest initializePaymentRequest = new InitializePaymentRequest( createOrderResponse.OrderId, order.TotalPrice.Value.WithVat, PaymentChannelId.Web, interfaceOptions );
if ( settings.ContainsKey( "paymentMethods" ) && !string.IsNullOrEmpty( settings[ "paymentMethods" ] ) ) {
initializePaymentRequest.WithPaymentMethods( settings[ "paymentMethods" ].Split( ',' ).Select( i => PaynovaPaymentMethod.Custom( int.Parse( i ) ) ) );
}
InitializePaymentResponse initializePaymentResponse = client.InitializePayment( initializePaymentRequest );
htmlForm.Action = initializePaymentResponse.Url;
} catch ( Exception e ) {
}
return htmlForm;
}
/// <remarks/>
public void CreateOrderAsync(CreateOrderRequest CreateOrderRequest, object userState) {
if ((this.CreateOrderOperationCompleted == null)) {
this.CreateOrderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateOrderOperationCompleted);
}
this.InvokeAsync("CreateOrder", new object[] {
CreateOrderRequest}, this.CreateOrderOperationCompleted, userState);
}
