public IHttpActionResult PutOrder(int id, OrderSet orderSet)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != orderSet.IdOrder)
{
return(BadRequest());
}
db.Entry(orderSet).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderSetExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PostOrder([FromBody] OrderSet orderSet)
{
// OrderSet orderSet = new OrderSet();
OrderTreatment _treatment = new OrderTreatment();
List <Product> Products = new List <Product>();
//orderSet =request;
foreach (var _item in db.OrderLineSet)
{
orderSet.OrderLineSet.Add(_item);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_treatment.Validation(ref orderSet, ref Products))
{
_treatment.Insert(orderSet);
}
else
{
}
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(orderSet.GetType());
var _StringWriter = new StringWriter();
XmlWriter _Writer = XmlWriter.Create(_StringWriter);
x.Serialize(_Writer, orderSet);
string _Xml = _StringWriter.ToString();
return(CreatedAtRoute("DefaultApi", new { id = orderSet.IdOrder }, _Xml));
}
public void Test(int choix)
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (choix == 1)
{
var response = client.GetAsync("http://localhost:52484/api/Product").Result;
Console.WriteLine(response);
}
else if (choix == 2)
{
var response = client.GetAsync("http://localhost:52484/api/OrderJson").Result;
Console.WriteLine(response);
}
else if (choix == 3)
{
OrderSet order = new OrderSet();
order.Date = DateTime.Now;
order.IsCanceled = false;
order.Note = "Commande de produits";
order.SupplierNumber = "45114";
order.TotalOfOrderLine = 2;
StringContent content = new StringContent(JsonConvert.SerializeObject(order), Encoding.UTF8, "application/json");
var response = client.PostAsync("http://localhost:52484/api/OrderJson", content).Result;
Console.WriteLine(response);
}
}
public IHttpActionResult PutOrder([FromBody] JObject Response)
{
OrderSet orderSet = new OrderSet();
orderSet = Response.ToObject <OrderSet>();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.OrderSet.Add(orderSet);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(StatusCode(HttpStatusCode.NoContent));
}
public OrderSet(OrderSet other) : this(bwapiPINVOKE.new_OrderSet__SWIG_1(OrderSet.getCPtr(other)), true)
{
if (bwapiPINVOKE.SWIGPendingException.Pending)
{
throw bwapiPINVOKE.SWIGPendingException.Retrieve();
}
}
public IHttpActionResult GetCreate_orderLine(string _IdO)
{
int _ido = int.Parse(_IdO);
OrderSet order = db.OrderSet.Find(_ido);
GenericImplement <OrderLineSet> _GenericMethod = new GenericImplement <OrderLineSet>();
if (order == null)
{
return(NotFound());
}
OrderLineSet _OrderLine = new OrderLineSet();
_GenericMethod.Insert(_OrderLine);
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(_OrderLine.GetType());
var _StringWriter = new StringWriter();
XmlWriter _Writer = XmlWriter.Create(_StringWriter);
x.Serialize(_Writer, _OrderLine);
string _Xml = _StringWriter.ToString();
return(Ok(_Xml));
}
public override global::System.Data.DataSet Clone()
{
OrderSet cln = ((OrderSet)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
public OrderSetEnumerator(OrderSet collection)
{
collectionRef = collection;
keyCollection = new global::System.Collections.Generic.List <Order>(collection.Values);
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
public IHttpActionResult GetOrder(int id)
{
GenericImplement <OrderSet> _GenericMethod = new GenericImplement <OrderSet>();
OrderSet _orderSet = _GenericMethod.Find(id);
if (_orderSet == null)
{
return(NotFound());
}
return(Ok(_orderSet));
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
OrderSet ds = new OrderSet();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
// GET: api/OrderXml
public IHttpActionResult GetOrder()
{
OrderSet _Order = new OrderSet();
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(_Order.GetType());
var _StringWriter = new StringWriter();
XmlWriter _Writer = XmlWriter.Create(_StringWriter);
x.Serialize(_Writer, _Order);
string _Xml = _StringWriter.ToString();
return(Ok(_Xml));
}
public IHttpActionResult DeleteOrder(int id)
{
OrderSet orderSet = db.OrderSet.Find(id);
if (orderSet == null)
{
return(NotFound());
}
db.OrderSet.Remove(orderSet);
db.SaveChanges();
return(Ok(orderSet));
}
public IHttpActionResult GetCreateOrder(string IdC)
{
int id = int.Parse(IdC);
Customer custumer = db.Customer.Find(id);
GenericImplement <OrderSet> _GenericMethod = new GenericImplement <OrderSet>();
if (custumer == null)
{
return(NotFound());
}
OrderSet order = new OrderSet();
_GenericMethod.Insert(order);
return(Ok(order));
}
public void NewOrder()
{
int allTablesFull = 0;
for (int i = 0; i < tables.Count; i++)
{
if (tables[i].hasOrder)
{
allTablesFull++;
}
}
if (allTablesFull < tables.Count)
{
int currentTable = CallTable();
int currentPos = 0;
OrderPosition currentPosition = null;
for (int i = 0; i < positions.Length; i++)
{
if (!positions[i].hasOrder)
{
currentPosition = positions[i];
currentPos = i;
break;
}
}
GameObject orderObject = Instantiate(orderPrefab, currentPosition.position, Quaternion.Euler(0, 90, -90));
int orderIndex = Random.Range(0, orderSets.Count);
OrderSet currentOrder = orderSets[orderIndex];
currentOrder.orderNumber = lastOrder + 1;
tables[currentTable].currentOrder = currentOrder;
tables[currentTable].hasOrder = true;
tables[currentTable].tablePosition = currentPos;
tables[currentTable].tableNumber = currentTable;
currentPosition.hasOrder = true;
orderObject.GetComponent <OrderPaper>().Init(lastOrder + 1, currentTable += 1, currentOrder.meat, currentOrder.tomato, currentOrder.lettuce, currentOrder.potato, currentOrder.egg, currentOrder.cheddar);;
activeOrders.Add(orderObject.GetComponent <OrderPaper>());
//
lastOrder++;
}
}
public IHttpActionResult GetOrder(int id)
{
OrderSet _Order = db.OrderSet.Find(id);
if (_Order == null)
{
return(NotFound());
}
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(_Order.GetType());
var _StringWriter = new StringWriter();
XmlWriter _Writer = XmlWriter.Create(_StringWriter);
x.Serialize(_Writer, _Order);
string _Xml = _StringWriter.ToString();
return(Ok(_Xml));
}
public IHttpActionResult GetOrderLinesOfOrder(string _IdO)
{
int _ido = int.Parse(_IdO);
OrderSet order = db.OrderSet.Find(_ido);
GenericImplement <OrderLineSet> _GenericMethod = new GenericImplement <OrderLineSet>();
if (order == null)
{
return(NotFound());
}
List <OrderLineSet> _orderLine = new List <OrderLineSet>();
_orderLine = db.OrderLineSet.Where(u => u.Order_Id == _ido).ToList();
return(Ok(_orderLine));
}
public void StoreLowestValueAtFirstIndex()
{
var context = MockStatefulServiceContextFactory.Default;
var stateManager = new MockReliableStateManager();
var orderSet = new OrderSet(stateManager, "test");
var order1 = new Order(CurrencyPair.GBPUSD, 10, 10);
var order2 = new Order(CurrencyPair.GBPUSD, 12, 5);
var order3 = new Order(CurrencyPair.GBPUSD, 5, 10);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order1);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order2);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order3);
var min = orderSet.GetMinOrder();
Assert.Equal(order3, min);
}
public void StoreOldesetOrderAtLastIndex()
{
var context = MockStatefulServiceContextFactory.Default;
var stateManager = new MockReliableStateManager();
var orderSet = new OrderSet(stateManager, "test");
var order1 = new Order(CurrencyPair.GBPUSD, 10, 10);
var order2 = new Order(CurrencyPair.GBPUSD, 10, 10);
var order3 = new Order(CurrencyPair.GBPUSD, 10, 10);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order1);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order2);
orderSet.SecondaryIndex = orderSet.SecondaryIndex.Add(order3);
var max = orderSet.GetMaxOrder();
Assert.Equal(order1, max);
}
private static async Task <DataTable> ExtractSalesData(GridView shoppingCart)
{
var Cart = shoppingCart;
return(await Task.Run(() =>
{
var data = new OrderSet().Tables[0];
for (int i = 0; i < Cart.RowCount; i++)
{
var row = data.NewRow();
row["Product Name"] = Cart.GetRowCellValue(i, "ProductName");
row["Unit Price"] = Cart.GetRowCellValue(i, "Price");
row["Qty"] = Cart.GetRowCellValue(i, "Quantity");
row["Sub Total"] = Cart.GetRowCellValue(i, "Total");
data.Rows.Add(row);
}
return data;
}));
}
public override void Seed()
{
System.Diagnostics.Debug.Print("Seeding db");
var alex = CustomerSet.Add(new Customer
{
Name = "Alex",
Id = Guid.NewGuid()
});
var jenny = CustomerSet.Add(new Customer
{
Name = "Jenny",
Id = Guid.NewGuid()
});
OrderSet.Add(new Order
{
Id = Guid.NewGuid(),
Name = "Zalando Bestellung",
OrderDate = new DateTime(2015, 01, 14),
Price = 150d,
Customer = jenny,
});
OrderSet.Add(new Order
{
Id = Guid.NewGuid(),
Name = "Amazon Bestellung",
OrderDate = new DateTime(2015, 02, 3),
Price = 85d,
Customer = alex,
});
OrderSet.Add(new Order
{
Id = Guid.NewGuid(),
Name = "Universalversand",
OrderDate = new DateTime(2015, 04, 20),
Price = 33.9d,
Customer = jenny
});
SaveChanges();
}
public bool SendPaidSuccessfully(string to, OrderSet order)
{
StringBuilder body = new StringBuilder();
body.AppendLine("Dear Customer,");
body.AppendLine();
body.AppendLine("Thank you for being our customer.");
body.AppendLine();
body.AppendLine($"The following order has been payed successfully:");
body.AppendLine();
body.AppendLine($"#{order.SerialNumber} {order.PaymentDateTime} [Delivary Cost:{order.OrderShipment.ShipmentCost} USD] [Net Discount:{order.NetItemsDiscountValue} USD] [Net items price:{order.NetItemsPrice} USD]");
body.AppendLine();
body.AppendLine($"Total: {order.Total} USD");
body.AppendLine();
body.AppendLine($"and will be shipped to your address {order.OrderShipment.Address} on {order.OrderShipment.ShippedTime}.");
body.AppendLine();
body.AppendLine($"Thanks.");
return(SendEmail("Customer Invoice", body.ToString(), to));
}
// POST: api/OrderJson?x=value
//[ResponseType(typeof(OrderSet))]
public IHttpActionResult PostSupplierResponse([FromBody] JObject Response, string x)
{
OrderTreatment _treatment = new OrderTreatment();
OrderSet _orderSet = new OrderSet();
List <Product> _products = new List <Product>();
string _Message = "";
_orderSet = Response["Order"].ToObject <OrderSet>();
_products = Response["Products"].ToObject <List <Product> >();
_Message = Response["Message"].ToObject <string>();
if (_treatment.OrderStatus(_products, ref _Message))
{
_treatment.Invoice(_orderSet);
}
return(CreatedAtRoute("DefaultApi", new { id = _orderSet.IdOrder }, Response));
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
string config = Convert.ToString(e.Argument);
using (var client = new NWindServiceClient(config))
{
OrderSet set = client.LoadFoo(), copy;
int count = cheekyCount;
copy = set;
string key = "Vanilla WCF via " + config;
Stopwatch fooWatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
copy = client.RoundTripFoo(copy);
if (i % 10 == 0)
{
backgroundWorker1.ReportProgress((i * 100) / count, key);
}
}
fooWatch.Stop();
copy = set;
key = "aqlaserializer via " + config;
Stopwatch barWatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
copy = client.RoundTripBar(copy);
if (i % 10 == 0)
{
backgroundWorker1.ReportProgress((i * 100) / count, key);
}
}
barWatch.Stop();
decimal pc = (barWatch.ElapsedMilliseconds * 100.0M) / fooWatch.ElapsedMilliseconds;
e.Result = string.Format("x{2} via {3} - Vanilla WCF: {0:###,##0}ms, protobuf-net: {1:###,##0}ms ({4:##.#}%)",
fooWatch.ElapsedMilliseconds, barWatch.ElapsedMilliseconds, count, config, pc);
}
}
public IHttpActionResult DeleteOrder(int id)
{
OrderSet orderSet = db.OrderSet.Find(id);
if (orderSet == null)
{
return(NotFound());
}
db.OrderSet.Remove(orderSet);
db.SaveChanges();
return(ResponseMessage(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <OrderSet>(orderSet,
new System.Net.Http.Formatting.XmlMediaTypeFormatter
{
UseXmlSerializer = true
})
}));
}
// POST: api/OrderJson
public IHttpActionResult PostOrder([FromBody] JObject Response)
{
OrderTreatment _treatment = new OrderTreatment();
OrderSet orderSet = new OrderSet();
orderSet = Response.ToObject <OrderSet>();
List <Product> Products = new List <Product>();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_treatment.Validation(ref orderSet, ref Products))
{
orderSet.Note = "Commande enregistrée";
//_treatment.Insert(orderSet);
//Products.Add(db.Product.FirstOrDefault());
}
else
{
orderSet.Note = "Certains élements de la commande ne sont pas identifiables";
}
if (Products.Count() == 0 || Products == null)
{
_treatment.Invoice(orderSet);
return(Ok(Products));
}
else
{
orderSet.Note = "Ces produits n'ont pas été trouvés";
return(CreatedAtRoute("DefaultApi", new { id = orderSet.IdOrder }, order));
}
}
public IHttpActionResult GetCreateOrder(string _IdC)
{
int _id = int.Parse(_IdC);
Customer custumer = db.Customer.Find(_id);
GenericImplement <OrderSet> _GenericMethod = new GenericImplement <OrderSet>();
if (custumer == null)
{
return(NotFound());
}
OrderSet _Order = new OrderSet();
_GenericMethod.Insert(_Order);
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(_Order.GetType());
var _StringWriter = new StringWriter();
XmlWriter _Writer = XmlWriter.Create(_StringWriter);
x.Serialize(_Writer, _Order);
string _Xml = _StringWriter.ToString();
return(Ok(_Xml));
}
private async Task <DataTable> GetDataTable(DataGridView shopping)
{
var Cart = shopping;
return(await Task.Run(() =>
{
var data = new OrderSet().Tables[0];
for (int i = 0; i < Cart.RowCount; i++)
{
DataRow row = data.NewRow();
row["Product"] = Cart.Rows[i].Cells["Product"];
row["Price"] = Cart.Rows[i].Cells["Price"];
row["Quantity"] = Cart.Rows[i].Cells["Quantity"];
row["Total"] = Cart.Rows[i].Cells["Total"];
data.Rows.Add(row);
BindingSource bs = new BindingSource();
bs.DataSource = data;
}
return data;
}));
}
private void Btn_Set_Click(object sender, RoutedEventArgs e)
{
UkrzaliznutsaDBEntities ukrzaliznutsaDBEntities = new UkrzaliznutsaDBEntities();
OrderSet order = new OrderSet
{
User = User.SelectedItem.ToString(),
Number = Number.SelectedItem.ToString(),
ContragentFrom = ContragentFrom.SelectedItem.ToString(),
ContragentTo = ContragentTo.SelectedItem.ToString(),
TypeVagon = TypeVadon.SelectedItem.ToString(),
PointStart = PointStart.SelectedItem.ToString(),
PointEnd = PointEnd.SelectedItem.ToString(),
PriceOfOrder = PriceOfOrder.Text,
Photo = photoload,
OrderPhoto = orderphoto,
InformationOfOrder = arrayread,
Marshrute = Marshrute.SelectedItem.ToString(),
AllInformation = Informationoforder.Text,
ProdactionInformation = Prodaction.Text
};
ukrzaliznutsaDBEntities.OrderSet.Add(order);
ukrzaliznutsaDBEntities.SaveChanges();
}
public void setOrder(string user, string number, string contragentfrom, string pointstart, string contragentto, string pointent, string typevagon, string pricoeoforder, byte[] photo, byte[] orderphoto, byte[] informationorder, string marshrute, string locomotive, string allinfo, string prodinfo)
{
OrderSet orders = new OrderSet
{
User = user,
Number = number,
ContragentFrom = contragentfrom,
PointStart = pointstart,
ContragentTo = contragentto,
PointEnd = pointent,
TypeVagon = typevagon,
PriceOfOrder = pricoeoforder,
Photo = photo,
OrderPhoto = orderphoto,
InformationOfOrder = informationorder,
Marshrute = marshrute,
Locomotive = locomotive,
AllInformation = allinfo,
ProdactionInformation = prodinfo
};
ukrzaliznutsaDBEntities.OrderSet.Add(orders);
ukrzaliznutsaDBEntities.SaveChanges();
}
private static NakedObjectActionSet CreateNakedObjectActionSet(OrderSet orderSet) {
return new NakedObjectActionSet(orderSet.GroupFullName.Replace(" ", ""), orderSet.GroupFullName, OrderActions(orderSet));
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(OrderSet obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public static OrderSet allOrders() {
OrderSet ret = new OrderSet(bwapiPINVOKE.allOrders(), false);
return ret;
}
private static INakedObjectAssociation[] OrderFields(OrderSet order) {
var orderedFields = new List<INakedObjectAssociation>();
foreach (IOrderableElement element in order) {
if (element is DotNetNakedObjectAssociationPeer) {
orderedFields.Add(CreateNakedObjectField((DotNetNakedObjectAssociationPeer) element));
}
else if (element is OrderSet) {
// Not supported at present
}
else {
throw new UnknownTypeException(element);
}
}
return orderedFields.ToArray();
}
private static INakedObjectAction[] OrderActions(OrderSet order) {
var actions = new List<INakedObjectAction>();
foreach (IOrderableElement element in order) {
if (element is DotNetNakedObjectActionPeer) {
actions.Add(CreateNakedObjectAction((DotNetNakedObjectActionPeer) element));
}
else if (element is OrderSet) {
actions.Add(CreateNakedObjectActionSet((OrderSet) element));
}
else {
throw new UnknownTypeException(element);
}
}
return actions.ToArray();
}
