public async Task <IActionResult> PostOrder(OrderPost order)
{
// Prepare
var orderDTO = new OrderDTO();
orderDTO.Products = order.Products;
var customer = store.customers.FirstOrDefault(c => c.CustomerId == order.CustomerId);
foreach (var product in orderDTO.Products)
{
customer.LifeTimeValue += product.UnitPrice * 1;
}
customer.OrderCount++;
orderDTO.Customer = customer;
// Post to Orders
using (var client = new HttpClient())
{
var url = $"https://localhost:{Mappings.addresses["orders"]}/api/orders";
var json = JsonConvert.SerializeObject(orderDTO);
var stringContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, stringContent);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
return(Ok("Sent to !"));
}
}
//Uses the summary order number to retrieve the order object from ShipStation API
//so that the order object to be returned will have the orderId
public static string GetOrderByOrderNumber(RestClient RestClient, ShippingSummary Summary)
{
Console.WriteLine("Grabbing Order by Order Number : {0}", Summary.Order_No);
try
{
RestRequest rrGetOrder = new RestRequest("orders", Method.GET);
rrGetOrder.AddParameter("orderNumber", Summary.Order_No);
IRestResponse responseOrder = RestClient.Execute(rrGetOrder);
JObject o = JObject.Parse(responseOrder.Content);
int orderId = int.Parse(o["orders"][0]["orderId"].ToString());
//make a new object to mark as shipped
OrderPost order = new OrderPost {
orderId = orderId,
trackingNumber = Summary.Tracking,
shipDate = Summary.Ship_Date,
carrierCode = "usps",
notifyCustomer = true,
notifySalesChannel = true
};
Thread.Sleep(500);
return(JsonConvert.SerializeObject(order));
}
catch (Exception ex)
{
return("An Error Has Occured " + ex.ToString());
}
}
public IActionResult AddOrder(OrderPost orderPost)
{
try
{
var order = new Order();
order.Customer = new Customer {
CustomerEmail = orderPost.Customer.Email,
CustomerId = orderPost.Customer.CustomerId,
CustomerName = orderPost.Customer.Name
};
order.PlacedOn = DateTime.Now;
order.OrderId = store.orders.Count + 1;
order.Items = new List <OrderItem>();
foreach (var item in orderPost.Products)
{
var orderItem = new OrderItem()
{
ItemId = 1000, ProductName = item.Name, Quantity = 1, UnitPriceInRupees = item.UnitPrice
};
order.Items.Add(orderItem);
}
store.orders.Add(order);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public ActionResult Post(OrderPost orderPost)
{
var order = _mapper.Map <Order>(orderPost);
_orders.AddOrder(order);
return(Ok());
}
public async Task <IActionResult> AddOrder(OrderPost order)
{
string userId = User.Claims.First(c => c.Type == "UserId").Value;
var user = await _userManager.FindByIdAsync(userId);
var O = new Order();
O.Owner = user;
foreach (Phone p in order.ListPhones)
{
var phone = _db.Phones.FirstOrDefault(x => x.PhoneName == p.PhoneName);
if (phone == null)
{
return(BadRequest());
}
else
{
OrderPhone orderPhone = new OrderPhone();
orderPhone.Phone = phone;
orderPhone.Order = O;
_db.OrderPhones.Add(orderPhone);
}
}
_db.Orders.Add(O);
_db.SaveChanges();
return(Ok(O));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Description,ArticleId,Quantity,Price,Total")] OrderPost orderPost)
{
if (id != orderPost.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(orderPost);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderPostExists(orderPost.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ArticleId"] = new SelectList(_context.Article, "Id", "Id", orderPost.ArticleId);
return(View(orderPost));
}
public async Task <IActionResult> PostOrder([FromBody] OrderPost order)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _orderServices.PostOrder(order);
return(Ok(result));
}
public async Task <IActionResult> Create([Bind("Id,Description,ArticleId,Quantity,Price,Total")] OrderPost orderPost)
{
if (ModelState.IsValid)
{
_context.Add(orderPost);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ArticleId"] = new SelectList(_context.Article, "Id", "Id", orderPost.ArticleId);
return(View(orderPost));
}
public IActionResult PostOrder([FromForm] OrderPost orderPost)
{
var order = new Order
{
UserId = _cookies.UserId,
Total = _cookies.Cart.Amount,
Description = orderPost.Description,
FirstName = orderPost.FirstName,
LastName = orderPost.LastName,
Address = orderPost.Address,
CreatedOn = DateTime.Now,
Products = JsonConvert.SerializeObject(_cookies.Cart.Items)
};
_context.Orders.Add(order);
_context.SaveChanges();
_cookies.Remove(CookiesName.Cart);
return(RedirectPermanent(Routing.AccountIndex));
}
public async Task <IActionResult> PostOrder(OrderPost order)
{
// Post to Product
using (var client = new HttpClient())
{
var url = $"https://localhost:{Mappings.addresses["products"]}/api/products/order";
var json = JsonConvert.SerializeObject(order);
var stringContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, stringContent);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
return(Ok("Posted Order!"));
}
// Get a query that gets the ordersThatMatch CustomerId
//return Ok();
}
public async Task <IActionResult> PostOrder(OrderPost order)
{
// Prepare
var orderDTO = new OrderDTO();
orderDTO.products = new List <Product>();
foreach (var productId in order.ProductIds)
{
var product = store.products.FirstOrDefault(p => p.ProductId == productId);
if (product == null)
{
return(BadRequest("Product Doesn't Exist"));
}
product.QuantityAtHand -= 1;
product.Sales += 1;
orderDTO.products.Add(product);
}
orderDTO.CustomerId = order.CustomerId;
// Post to Customer
using (var client = new HttpClient())
{
var url = $"https://localhost:{Mappings.addresses["customers"]}/api/customers/order";
var json = JsonConvert.SerializeObject(orderDTO);
var stringContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var response = await client.PostAsync(url, stringContent);
try
{
response.EnsureSuccessStatusCode();
}catch (Exception e)
{
return(BadRequest("There was a problem with your request"));
}
string content = await response.Content.ReadAsStringAsync();
return(Ok("Sent to !"));
}
}
public IActionResult PostDelivery(OrderPost order)
{
var text = "Your type of order - post delivery. For more information follow the link: https://mayakelectronics20191126070610.azurewebsites.net/Account/YourAccount";
var items = _cart.GetCartItems();
ViewBag.Total = _cart.GetCartTotal();
ViewBag.Items = items;
if (items.Count == 0)
{
ModelState.AddModelError("", "Cart is empty");
}
new EfProductRepository().UpdateAreBoughts(items.Select(i => i.Product).ToList());
if (ModelState.IsValid)
{
EmailSender.SendEmail(order.Email, text);
_cart.ClearCart();
_orderRepository.CreateOrder(order);
return(RedirectToAction("Complete"));
}
return(View(order));
}
public void CreateOrder(OrderPost order)
{
order.OrderPlaced = DateTime.Now;
_db.OrdersPost.Add(order);
_db.SaveChanges();
order.OrderTotal = _cart.GetCartTotal();
var cartItems = _cart.CartItems;
foreach (var item in cartItems)
{
var orderDetail = new OrderDetailPost()
{
Amount = item.Amount,
ProductId = item.Product.Id,
OrderPostId = order.OrderPostId,
Price = item.Product.Price
};
_db.OrderDetailsPost.Add(orderDetail);
}
_db.SaveChanges();
}
public OrderInfo InsertOrder(OrderPost post)
{
var result = new OrderInfo();
var userObjId = new ObjectId(post.userId);
//获取最近一个订单信息
var builderOrder = Builders<OrderMongo>.Filter;
var filterOrder = builderOrder.Eq(x => x.UserId, userObjId);
filterOrder &= builderOrder.Eq(x => x.IsDel, false);
var colOrder = MongoDBHelper.Instance.GetOrder();
try
{
//判断两个订单时间间隔，避免短时间频繁提交订单
var queryOrder = colOrder.Find(filterOrder).SortByDescending(x => x.CreatedAt).FirstOrDefault();
if (queryOrder != null)
{
TimeSpan interval = DateTime.Now - queryOrder.CreatedAt;
if (interval.TotalSeconds < 10)
return null;
}
//根据产品Id获取产品信息
var productObjIdList = post.productList.Select(x => new ObjectId(x.id)).ToList();
var buiderProduct = Builders<ProductMongo>.Filter;
var filterProduct = buiderProduct.In(x => x._id, productObjIdList);
filterProduct &= buiderProduct.Eq(x => x.IsDel, false);
var queryProduct = MongoDBHelper.Instance.GetProduct().Find(filterProduct).ToList();
var productList = new List<ProductInOrder>(); //订单内产品信息列表
var proDtoList = new List<ProductInOrderDto>(); //返回给前端的订单内产品信息列表
foreach (var x in queryProduct)
{
var product = new ProductInOrder
{
_id = x._id,
Name = x.Name,
Description = x.Description,
Price = x.Price
};
product.Num = post.productList.Find(s => s.id == x._id.ToString()).Num;
productList.Add(product);
var proDto = new ProductInOrderDto
{
Id = x._id.ToString(),
Name = x.Name,
Description = x.Description,
Price = x.Price,
Num=product.Num,
};
proDtoList.Add(proDto);
}
<<<<<<< HEAD
var order = new OrderMongo
{
_id=ObjectId.GenerateNewId(),
CreatedAt = DateTime.Now.AddHours(8),
ProductList = productList,
UserId = userObjId
=======
var ran = new Random();
string tradeNo = string.Format("DT{0}{1}", DateTime.Now.ToString("yyyyMMddHHmmss"), ran.Next(9999));
var order = new OrderMongo
{
_id = ObjectId.GenerateNewId(),
CreatedAt = DateTime.Now.AddHours(8),
ProductList = productList,
UserId = userObjId,
TradeNo = tradeNo
>>>>>>> c26f92d240a523a1903a8e87db204683ad299860
};
order.TotalPrice = productList.Select(x => x.Num * x.Price).Sum();
colOrder.InsertOne(order);
order.ProductList = productList;
var orderDto = new OrderDto
{
Id = order._id.ToString(),
ProductList = proDtoList,
<<<<<<< HEAD
TotalPrice = order.TotalPrice
=======
TotalPrice = order.TotalPrice,
CreatedAt = order.CreatedAt,
TradeNo = order.TradeNo
>>>>>>> c26f92d240a523a1903a8e87db204683ad299860
};
result.order = orderDto;
public async Task <IActionResult> Post(OrderPost order)
{
return(Ok(order));
}
public async Task <IActionResult> PostOrder([FromHeader] string Authorization, [FromBody] OrderPost orderPost)
{
try
{
long timestamp = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
long markpricetimestamp = timestamp;// - DateTime.UtcNow.Second;
if (Request.ContentType == "application/json")
{
;
}
else
{
return(BadRequest("improper content type"));
}
if (orderPost.OrderType == "limit")
{
if (string.IsNullOrEmpty(orderPost.Contract) && string.IsNullOrEmpty(orderPost.OrderType) && string.IsNullOrEmpty(orderPost.Price) && orderPost.OrderQuantity == null)
{
return(BadRequest("bad params"));
}
}
else if (orderPost.OrderType == "market")
{
if (string.IsNullOrEmpty(orderPost.Contract) && string.IsNullOrEmpty(orderPost.OrderType) && orderPost.OrderQuantity == null)
{
return(BadRequest("bad params"));
}
}
else
{
return(BadRequest("missing params"));
}
Console.WriteLine(orderPost.Contract + orderPost.OrderQuantity + orderPost.OrderType + orderPost.Side);
if (string.IsNullOrEmpty(orderPost.Contract) || string.IsNullOrEmpty(orderPost.OrderType) || string.IsNullOrEmpty(orderPost.Side) || orderPost.OrderQuantity == null)
{
return(BadRequest("missing variables"));
}
AmazonDynamoDBClient amazonDynamoDBClient = new AmazonDynamoDBClient();
Table UserTable = Table.LoadTable(amazonDynamoDBClient, "UserDetailsRegistry");
Table SPXMarkTable = Table.LoadTable(amazonDynamoDBClient, "SPXMarkPrice");
Document searchdetails = new Document();
orderPost.OrderType = orderPost.OrderType.ToLower();
int orderId;
string socket;
try
{
string[] autharray = Authorization.Split(' ');
string authtype = autharray[0];
string authstring = autharray[1];
if (authtype == "Basic")
{
byte[] data = Convert.FromBase64String(authstring);
string decodedString = Encoding.UTF8.GetString(data);
string[] splitauth = decodedString.Split(":");
string id = splitauth[0];
string secret = splitauth[1]; Console.WriteLine(id + secret);
ScanOperationConfig scanOperation = new ScanOperationConfig();
ScanFilter scanFilter = new ScanFilter();
scanFilter.AddCondition("DefaultId", ScanOperator.Equal, id);
Search search = UserTable.Scan(scanOperation);
List <Document> details = await search.GetRemainingAsync();
foreach (Document doc in details)
{
if (doc["DefaultSecret"] == secret && doc["DefaultId"] == id)
{
Console.WriteLine("successful auth");
searchdetails = doc;
break;
}
else
{
continue;
}
}
searchdetails["Email"].ToString();
}
else
{
return(BadRequest("Bad authorization"));
}
// verifiy valid account balance
Document userdetails = await UserTable.GetItemAsync(searchdetails["Email"].ToString());
Document markprice = new Document();
markpricetimestamp = markpricetimestamp - (markpricetimestamp % 5);
try { markprice = await SPXMarkTable.GetItemAsync(markpricetimestamp.ToString()); markprice["BTCPrice"].ToString(); }
catch { try { markpricetimestamp -= 5; markprice = await SPXMarkTable.GetItemAsync((markpricetimestamp).ToString()); markprice["BTCPrice"].ToString(); } catch { Console.WriteLine("bigbad"); } }
double availablebalance = searchdetails["AvailableBalance"].AsDouble();
if (orderPost.OrderQuantity > ((availablebalance * markprice["BTCPrice"].AsDouble()) * 100))
{
return(BadRequest("bad amount"));
}
// atomic id generate
Table idgenerator = Table.LoadTable(amazonDynamoDBClient, "IdGenerator");
Document currentid = await idgenerator.GetItemAsync("Main");
Document newid = new Document();
newid["Id"] = "Main";
double count = currentid["Count"].AsDouble();
count += 1;
newid["Count"] = count.ToString();
UpdateItemOperationConfig updateItemOperationConfig = new UpdateItemOperationConfig();
ExpectedValue expected = new ExpectedValue(ScanOperator.Equal);
updateItemOperationConfig.Expected = currentid;
try
{
Document test = await idgenerator.UpdateItemAsync(newid, updateItemOperationConfig);
orderId = (int)count;
}
catch
{
return(BadRequest("please try again"));
}
Table orderreg = Table.LoadTable(amazonDynamoDBClient, "OrderRegistry");
Document addorder = new Document();
addorder["Id"] = orderId.ToString();
addorder["Email"] = searchdetails["Email"].ToString();
addorder["Side"] = orderPost.Side.ToString();
if (orderPost.OrderType == "limit")
{
addorder["Price"] = orderPost.Price.ToString();
}
addorder["OrderQuantity"] = orderPost.OrderQuantity.ToString();
addorder["Contract"] = orderPost.Contract;
addorder["OrderType"] = orderPost.OrderType;
addorder["Status"] = "open";
addorder["Timestamp"] = timestamp.ToString();
//addorder["Add"] = "true";
await orderreg.PutItemAsync(addorder);
// send tcp message to engine
try
{
TcpClient tcpclnt = new TcpClient();
Console.WriteLine("Connecting.....");
tcpclnt.Connect("52.213.34.99", port);
// use the ipaddress as in the server program
Console.WriteLine("Connected");
Console.Write("Enter the string to be transmitted : ");
var enginepayload = new object();
double spymark = markprice["SPXPrice"].AsDouble();
spymark = Math.Round(spymark);
spymark *= 100;
if (orderPost.OrderType == "limit")
{
enginepayload = new
{
Method = "Post",
Side = orderPost.Side,
Id = orderId.ToString(),
Price = orderPost.Price,
OrderQuantity = orderPost.OrderQuantity.ToString(),
OrderType = orderPost.OrderType,
Contract = orderPost.Contract,
Secret = "secret",
//Timestamp = timestamp.ToString(),
//User = searchdetails["Email"].ToString(),
//AvailableBalance = searchdetails["AvailableBalance"].ToString()
};
}
else if (orderPost.OrderType == "market")
{
enginepayload = new
{
Method = "Post",
Side = orderPost.Side,
Id = orderId.ToString(),
OrderQuantity = orderPost.OrderQuantity.ToString(),
Slippage = 99999.ToString(),
OrderType = orderPost.OrderType,
Contract = orderPost.Contract,
Secret = "secret",
//Timestamp = timestamp.ToString(),
//User = searchdetails["Email"].ToString(),
//AvailableBalance = searchdetails["AvailableBalance"].ToString()
};
}
else
{
return(BadRequest("invalid order type"));
}
using (SslStream sslStream = new SslStream(tcpclnt.GetStream(), false,
new RemoteCertificateValidationCallback(ValidateServerCertificate), null))
{
sslStream.AuthenticateAsClient("52.213.34.99");
// This is where you read and send data
String str = "enginekey" + JsonConvert.SerializeObject(enginepayload);
//Stream stm = tcpclnt.GetStream();
ASCIIEncoding asen = new ASCIIEncoding();
byte[] ba = asen.GetBytes(str);
Console.WriteLine("Transmitting.....");
sslStream.Write(ba, 0, ba.Length);
//sslStream.Close();
/*byte[] bb = new byte[1000];
* int k = await sslStream.ReadAsync(bb, 0, 1000);
*
* var socketresult = Encoding.UTF8.GetString(bb).TrimEnd('\0');
* Console.WriteLine(socketresult);
* socket = socketresult;*/
}
tcpclnt.Close();
}
catch (Exception e)
{
Console.WriteLine("Error..... " + e.StackTrace);
return(BadRequest("error with engine"));
}
}
catch
{
return(BadRequest("failed processing"));
}
var returnobj = new { Id = orderId, Timestamp = markpricetimestamp.ToString(), Message = "transmitted", Result = "sucess" };
string returnjson = JsonConvert.SerializeObject(returnobj);
return(Content(returnjson, "application/json"));
}
catch
{
return(BadRequest("something went wrong"));
}
}
