public static OrderElementEntity ToEntity(this OrderElement element)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <OrderElement, OrderElementEntity>());
var mapper = new Mapper(config);
return(mapper.Map <OrderElement, OrderElementEntity>(element));
}
public async Task <IActionResult> ConfirmOrder([FromBody] List <ShoppingCartItem> shoppingCartItems)
{
if (ModelState.IsValid)
{
var customer = dataManager.customerRepository.GetCustomerByUserName(User.Identity.Name);
Order order = new Order(customer.Id);
dataManager.orderRepository.SaveOrder(order);
foreach (var item in shoppingCartItems)
{
OrderElement element = new OrderElement(order, item);
dataManager.orderElementRepository.SaveOrderElement(element);
}
await dataManager.Commit();
await ClearAll();
return(Json(new ActionConfirmResult()));
}
return(Json(new ActionConfirmResult {
Errors = ModelState.SelectMany(s => s.Value.Errors.Select(e => e.ErrorMessage)).ToList()
}));
}
public OrderElement GetOrderElement()
{
var orderElement = new OrderElement("", 0, 0);
orderElement.Add(ProductType.Cup);
if (m_productType != ProductType.None)
{
orderElement.Add(m_productType);
}
if (HasIce())
{
orderElement.Add(ProductType.Ice);
}
if (HasStraw())
{
orderElement.Add(ProductType.Straw);
}
if (HasLid())
{
orderElement.Add(ProductType.Lid);
}
return(orderElement);
}
public OrderElement Clone()
{
var clone = new OrderElement(Name, Price, Time);
clone.InsertRange(0, this);
return(clone);
}
private void Item1_Click(object sender, RoutedEventArgs e)
{
List <OrderElement> list = new List <OrderElement>();
for (int i = 0; i < 10; i++)
{
OrderElement OE = new OrderElement();
list.Add(OE);
}
int price = 50;
List <string> names = new List <string>()
{
"Предмет 1", "Предмет 2", "Предмет 3", "Предмет 4", "Предмет 5", "Предмет 6", "Предмет 7", "Предмет 8", "Предмет 9", "Предмет 10"
};
int counter = 0;
foreach (var item in list)
{
item.cost = price;
item.ElementCount.Content = price;
item.ElementName.Content = names[counter];
OrderList.Items.Add(item);
price = (price + 100);
counter++;
}
Price.Content = 100 + (counter * price);
}
public async Task <IActionResult> Create([Bind("Id,Login,FirstName,LastName,Address")] Order order)
{
if (ModelState.IsValid)
{
order.CreatedAt = DateTime.Now;
await _context.AddAsync(order);
CartB cartB = new CartB(_context, this.HttpContext);
var elements = await cartB.GetCartElements();
foreach (var element in elements)
{
var orderElement = new OrderElement()
{
ProductId = element.ProductId,
OrderId = order.Id,
Price = element.Product.Price,
Count = element.Count
};
await _context.OrderElement.AddAsync(orderElement);
}
order.Sum = await cartB.GetCartSum();
cartB.ClearCart();
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = order.Id }));
}
return(View(order));
}
public static bool Compare(Order order1, Order order2)
{
if (order1.m_orderElements.Count != order2.m_orderElements.Count)
{
return(false);
}
order1 = order1.Clone();
order2 = order2.Clone();
foreach (var orderElement1 in order1.m_orderElements)
{
var find = order2.m_orderElements.Find((t) => {
return(OrderElement.Compare(orderElement1, t));
});
if (find == null)
{
return(false);
}
order2.m_orderElements.Remove(find);
}
return(true);
}
public void fetchMyOrders()
{
//on va commencer par exporter les données des orders en cliquant sur le bouton
Automation.I.mouseClick(ExportLocation);
Automation.I.waitAWhile();
//ensuite on importe les commandes
var directory = new DirectoryInfo("C:\\Users\\Stéphane\\Documents\\EVE\\logs\\Marketlogs");
var myOrdersFile = directory.GetFiles()
.OrderByDescending(f => f.LastWriteTime)
.First();
TextFieldParser parser = new TextFieldParser(myOrdersFile.FullName);
parser.TextFieldType = FieldType.Delimited;
parser.SetDelimiters(",");
int index = 0;
List <OrderElement> newOrders = new List <OrderElement>();
while (!parser.EndOfData)
{
string[] fields = parser.ReadFields();
if (index != 0)
{
OrderElement toAdd = new OrderElement(double.Parse(fields[10], CultureInfo.InvariantCulture), bool.Parse(fields[9]));
toAdd.orderId = fields[0];
toAdd.typeId = fields[1];
toAdd.charId = fields[2];
toAdd.charName = fields[3];
toAdd.regionId = fields[4];
toAdd.regionName = fields[5];
toAdd.stationId = fields[6];
toAdd.stationName = fields[7];
toAdd.range = int.Parse(fields[8]);
toAdd.volumeEntered = int.Parse(fields[11]);
toAdd.volumeRemaining = double.Parse(fields[12], CultureInfo.InvariantCulture);
toAdd.issueDate = DateTime.Parse(fields[13]);
toAdd.orderState = fields[14];
toAdd.minVolume = int.Parse(fields[15]);
toAdd.accountId = fields[16];
toAdd.duration = int.Parse(fields[17]);
toAdd.isCorp = bool.Parse(fields[18]);
toAdd.solarSystemId = fields[19];
toAdd.solarSystemName = fields[20];
toAdd.escrow = double.Parse(fields[21], CultureInfo.InvariantCulture);
newOrders.Add(toAdd);
}
index++;
}
oldOrders = orders;
orders = newOrders;
parser.Close();
Automation.I.waitAWhile();
try
{
File.Delete(myOrdersFile.FullName);
}catch (Exception e) {}
}
public string Create(OrderViewModel viewModel)
{
DateTime createdAt = DateTime.Now;
if (viewModel.SelectedItems != null)
{
List <OrderElement> distinctOrderElements =
viewModel.SelectedItems.GroupBy(s => s.ItemName).Select(s => new OrderElement()
{
ItemName = s.First().ItemName,
Quantity = s.Sum(q => q.Quantity)
}).ToList();
foreach (var element in distinctOrderElements)
{
Item item = db.Items.SingleOrDefault(e => e.Name == element.ItemName);
if (element.Quantity > item.QuantityInStock)
{
ViewBag.ErrorMessage = "Number of items in order exceeds warehouse stock";
ModelState.AddModelError("", "Number of items in order exceeds warehouse stock");
return("Number of items in order exceeds warehouse stock");
}
}
}
Order order = new Order
{
CreatedAt = createdAt
};
if (viewModel.SelectedItems != null)
{
foreach (OrderElement element in viewModel.SelectedItems)
{
OrderElement orderElement = new OrderElement
{
ItemName = element.ItemName,
Quantity = element.Quantity,
OrderId = viewModel.Id
};
db.OrderElements.Add(orderElement);
Item affectedItemInWarehouse = db.Items.SingleOrDefault(i => i.Name == orderElement.ItemName);
if (affectedItemInWarehouse != null)
{
affectedItemInWarehouse.QuantityInStock -= orderElement.Quantity;
db.Entry(affectedItemInWarehouse).State = EntityState.Modified;
}
}
}
db.Orders.Add(order);
db.SaveChanges();
return("OK");
}
public List <Order> GetOrdersList()
{
List <Order> list = new List <Order>();
foreach (XElement OrderElement in OrdersRoot.Elements())
{
list.Add(getOrder(int.Parse(OrderElement.Element("OrderID").Value)));
}
return(list);
}
public void SendOrder(Order O)
{
XElement OrderElement;
OrderElement = (from o in OrdersRoot.Elements()
where Convert.ToInt32(o.Element("OrderID").Value) == O.orderID && o.Element("OrderSituation").Value == OrderSituation.ORDERED.ToString()
select o).FirstOrDefault();
OrderElement.Element("OrderSituation").Value = OrderSituation.SENT.ToString();
OrdersRoot.Save(OrdersPath);
}
public void Remove(OrderElement domain)
{
var result = unitOfWork.OrderElemet.GetBy(orderElement => orderElement.Id == domain.Id);
if (result != null)
{
unitOfWork.OrderElemet.Remove(result);
unitOfWork.Save();
}
}
public void SingleOrder()
{
Order order1 = new Order(0);
Order order2 = new Order(0);
Assert.That(Order.Compare(order1, order2));
Assert.That(Order.Compare(order2, order1));
var orderElement1 = new OrderElement("order1", 1.0f, 1.0f);
order1.OrderElements.Add(orderElement1);
var orderElement2 = new OrderElement("order2", 1.0f, 1.0f);
order2.OrderElements.Add(orderElement2);
Assert.That(Order.Compare(order1, order2));
Assert.That(Order.Compare(order2, order1));
// order1 = IceTea
// order2 =
orderElement1.Add(ProductType.IceTea);
Assert.That(!Order.Compare(order1, order2));
// order1 = IceTea
// order2 = BeefRaw
orderElement2.Add(ProductType.BeefRaw);
Assert.That(!Order.Compare(order1, order2));
Assert.That(!Order.Compare(order2, order1));
// order1 = IceTea, BeefRaw
// order2 = BeefRaw
orderElement1.Add(ProductType.BeefRaw);
Assert.That(!Order.Compare(order1, order2));
Assert.That(!Order.Compare(order2, order1));
// order1 = IceTea, BeefRaw
// order2 = BeefRaw, IceTea
orderElement2.Add(ProductType.IceTea);
Assert.That(Order.Compare(order1, order2));
Assert.That(Order.Compare(order2, order1));
// order1 = IceTea, BeefRaw, BeefRaw
// order2 = BeefRaw, IceTea, BeefRaw
orderElement1.Add(ProductType.BeefRaw);
orderElement2.Add(ProductType.BeefRaw);
Assert.That(Order.Compare(order1, order2));
Assert.That(Order.Compare(order2, order1));
// order1 = IceTea, BeefRaw, BeefRaw
// order2 = BeefRaw, IceTea, BeefRaw, BeefRaw
orderElement2.Add(ProductType.BeefRaw);
Assert.That(!Order.Compare(order1, order2));
Assert.That(!Order.Compare(order2, order1));
}
public void SaveOrderElement(OrderElement entity)
{
if (entity.ID == default)
{
context.Entry(entity).State = EntityState.Added;
}
else
{
context.Entry(entity).State = EntityState.Modified;
}
}
public IActionResult StartGrowElement(OrderElement element)
{
using (Database db = new Database())
{
element = db.OrderElements.First(x => x.Id == element.Id);
element.isGrow = true;
element.GrowStart = DateTime.Now;
db.SaveChanges();
}
return(RedirectToAction("Calendar"));
}
[HttpPost("addtocart")] //Добавить товары в корзину - Ok
public async Task <IActionResult> AddItemToShopCart([FromBody] AddItemsToShopCart requestmodel)
{
if (ModelState.IsValid)
{
var item = await unitOfWork.Items.GetAsync(requestmodel.ItemId);
bool iskey = HttpContext.Request.Cookies.ContainsKey("OrderId");
if (iskey == false) //ключ в куки не существует
{
Guid OrderId = Guid.NewGuid();
Order neworder = new Order()
{
CustomerId = (await unitOfWork.Customers.GetCurrentCustomer(HttpContext)).Id,
OrderId = OrderId,
OrderElements = new List <OrderElement> {
new OrderElement(requestmodel.ItemId, requestmodel.ItemCount)
{
ItemPrice = item.Price * requestmodel.ItemCount,
OrderId = OrderId
}
}
};
await unitOfWork.Orders.CreateAsync(neworder);
HttpContext.Response.Cookies.Append("OrderId", Convert.ToString(neworder.OrderId));
return(Ok("Вы создали корзину и положили туда " + requestmodel.ItemCount + " товара"));
}
else //ключ в куки существует
{
Guid OrderId = Guid.Parse(HttpContext.Request.Cookies["OrderId"]);
var order = await unitOfWork.Orders.GetAsync(OrderId);
OrderElement orderElement = new OrderElement(requestmodel.ItemId, requestmodel.ItemCount)
{
ItemPrice = item.Price * requestmodel.ItemCount,
OrderId = OrderId,
Order = order,
OrderElementId = Guid.NewGuid()
};
await unitOfWork.OrderElements.CreateAsync(orderElement);
order.OrderElements.Add(await unitOfWork.OrderElements.GetAsync(orderElement.OrderElementId));
return(Ok("Вы добавили " + requestmodel.ItemCount + " товара в корзину"));//a + "\nOrderId: " + OrderId);
}
}
else
{
return(BadRequest("Incorrect input"));
}
}
public bool AddElement(OrderElement elemet)
{
if (elemet == OrderElement.File && Order.Contains(OrderElement.File))
{
return(false);
}
if (Order.Any() && elemet == Order.Last())
{
return(false);
}
Order.Add(elemet);
return(true);
}
public override void orderStatus(int orderId, string status, double filled, double remaining, double avgFillPrice, int permId, int parentId, double lastFillPrice, int clientId, string whyHeld, double mktCapPrice)
{
var newStatus = new OrderStatus()
{
AvgFillPrice = avgFillPrice,
ClientId = clientId,
Filled = filled,
Remaining = remaining,
LastFillPrice = lastFillPrice,
MktCapPrice = mktCapPrice,
ParentId = parentId,
PermId = permId,
Status = status,
WhyHeld = whyHeld
};
lock (orderLocker)
{
if (orderToAccountMapping.TryGetValue(orderId, out var accountName))
{
var account = accountList[accountName];
account.Sync.WaitOne();
var placedOrder = account.OrderContainer.Orders.FirstOrDefault(e => e.Order.OrderId == orderId);
placedOrder.OrderStatus = newStatus;
orderToAccountMapping.TryRemove(orderId, out var elem);
account.Sync.ReleaseMutex();
}
else
{
var newOrder = new OrderElement()
{
Order = null,
OrderState = null,
Contract = null,
OrderStatus = newStatus,
};
hangingOrders.TryAdd(orderId, newOrder);
}
}
Console.WriteLine("OrderStatus. Id: " + orderId + ", Status: " + status + ", Filled" + filled + ", Remaining: " + remaining
+ ", AvgFillPrice: " + avgFillPrice + ", PermId: " + permId + ", ParentId: " + parentId + ", LastFillPrice: " + lastFillPrice + ", ClientId: " + clientId + ", WhyHeld: " + whyHeld + ", MktCapPrice: " + mktCapPrice);
}
public string AddItemToUserBasket(Item item)
{
var userCustomer = GetCurrentUser();
if (userCustomer == null)
{
return("Администратор не является Customer client, поэтому не может добавлять товары в корзину");
}
Order startOrder;
if (userCustomer.Order.SingleOrDefault(x => x.Status == "Новый") == null)
{
startOrder = new Order()
{
Customer = userCustomer,
OrderDate = DateTime.Now,
Status = "Новый",
OrderNumber = db.Orders.GetOrderNumber()
};
db.Orders.Create(startOrder);
}
else
{
startOrder = userCustomer.Order.SingleOrDefault(x => x.Status == "Новый");
}
OrderElement newOrderElement = startOrder.OrderElement.SingleOrDefault(x => x.ItemId == item.ItemId);
if (newOrderElement != null)
{
ChangeItemCountInBasket(item, newOrderElement.ItemsCount + 1);
}
else
{
newOrderElement = new OrderElement()
{
ItemId = item.ItemId,
OrderId = startOrder.OrderId,
ItemsCount = 1,
ItemPrice = item.Price
};
db.OrderElements.Create(newOrderElement);
}
db.Save();
return("successful item element added in basket");
}
// GET: Orders
public ActionResult Index(int?page)
{
IEnumerable <OrderElement> ord = new Queue <OrderElement>();
List <OrderElement> list = new List <OrderElement>();
var order = from m in db.Orders select m;
var userId = User.Identity.GetUserId();
order = order.Where(s => s.UserId == userId);
var users = from m in dbU.UserInfoes select m;
users = users.Where(s => s.UserId == userId);
ViewBag.UserName = users.First().Firstname;
ViewBag.LastName = users.First().Lastname;
foreach (var item in order)
{
var productId = item.ProductId;
var product = dbP.SW_Product.Find(productId);
OrderElement oE = new OrderElement();
oE.Logo = product.Logo;
oE.OrderId = item.OrderId;
oE.ProductId = product.IDProduct;
oE.ProductName = product.Name;
oE.ProductPrice = product.Price;
oE.Tag = product.Tag;
oE.UserId = item.UserId;
oE.Date = item.Date;
ord = list.AsEnumerable <OrderElement>();
list.Add(oE);
}
ViewBag.list = list;
int pageSize = 5;
int pageNumber = (page ?? 1);
return(View(ord.ToPagedList(pageNumber, pageSize)));
}
public OrderElement GetOrderElement()
{
var orderElement = new OrderElement("", 0, 0);
for (int i = 0; i < m_ingridientContainer.childCount; i++)
{
var child = m_ingridientContainer.GetChild(i);
var elementType = child.GetComponent <ProductTypeContainerBase>();
if (elementType != null)
{
orderElement.Add(elementType.GetProductType());
}
}
return(orderElement);
}
public bool deleteOrder(long key)
{
XElement OrderElement;
try
{
OrderElement = (from item in OrderRoot.Elements()
where int.Parse(item.Element("OrderKey").Value) == key
select item).FirstOrDefault();
OrderElement.Remove();
OrderRoot.Save(OrderdPath);
return(true);
}
catch
{
return(false);
}
}
public static bool Compare(OrderElement element1, OrderElement element2)
{
if (element1.Count != element2.Count)
{
return(false);
}
element1 = element1.Clone();
element2 = element2.Clone();
element1.Sort();
element2.Sort();
for (int i = 0; i < element1.Count; i++)
{
if (element1[i] != element2[i])
{
return(false);
}
}
return(true);
}
public void updateSaleType(string type)
{
int index = 0;
List <ObjectOtherOrders> buyOrderData = fetchOrderData(type, index);
while (buyOrderData != null && buyOrderData.Count > 0)
{
//on va aller voir à laquelle de nos commandes ça correspond
OrderElement myOrderForThisItem = orders.Where(o => (buyOrderData.Where(bod => bod.orderId == o.orderId && bod.bid == (type == "buy")).Count()) > 0).First();
double newPrice = myOrderForThisItem.getUpdatedPrice(buyOrderData);
if (newPrice > 0)
{
//MessageBox.Show("Présent Montant: "+ myOrderForThisItem.orderAmmount.ToString() + " Montant: " + newPrice.ToString());
modifyOrderSpecificElement(type, index, newPrice, myOrderForThisItem.orderAmmount);
}
index++;
Automation.I.waitAWhile();
buyOrderData = fetchOrderData(type, index);
}
//on
return;
}
public string ElemetToString(OrderElement element)
{
switch (element)
{
case OrderElement.Album:
return("Album");
case OrderElement.Artist:
return("Artist");
case OrderElement.File:
return(string.Format("<{0}>.<ext>", FileNameTemplate));
case OrderElement.Genre:
return("Genre");
case OrderElement.Year:
return("Year");
default:
return("");
}
}
// GET: Orders/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Order order = db.Orders.Find(id);
if (order == null)
{
return(HttpNotFound());
}
var userId = User.Identity.GetUserId();
var users = from m in dbU.UserInfoes select m;
users = users.Where(s => s.UserId == userId);
ViewBag.UserName = users.First().Firstname;
ViewBag.LastName = users.First().Lastname;
var productId = order.ProductId;
var product = dbP.SW_Product.Find(productId);
OrderElement oE = new OrderElement();
oE.Logo = product.Logo;
oE.Image = product.Image;
oE.Description = product.Description;
oE.OrderId = order.OrderId;
oE.ProductId = product.IDProduct;
oE.ProductName = product.Name;
oE.ProductPrice = product.Price;
oE.Tag = product.Tag;
oE.UserId = order.UserId;
oE.Date = order.Date;
if (order.Type == 0)
{
oE.Type = "New Product";
}
else
{
oE.Type = "Licence renewal";
}
if (order.Status == 0)
{
oE.Status = "Waiting for realisation";
}
else if (order.Status == 1)
{
oE.Status = "Realised";
}
else
{
oE.Status = "Canceled";
}
ViewBag.oe = oE;
return(View());
}
public string Edit(OrderViewModel viewModel)
{
DateTime now = DateTime.Now;
if (viewModel.SelectedItems != null)
{
List <OrderElement> distinctOrderElements =
viewModel.SelectedItems.GroupBy(s => s.ItemName).Select(s => new OrderElement()
{
ItemName = s.First().ItemName,
Quantity = s.Sum(q => q.Quantity)
}).ToList();
foreach (var element in distinctOrderElements)
{
Item item = db.Items.SingleOrDefault(e => e.Name == element.ItemName);
if (element.Quantity > item.QuantityInStock)
{
ViewBag.ErrorMessage = "Number of items in order exceeds warehouse stock";
ModelState.AddModelError("", "Number of items in order exceeds warehouse stock");
return("Number of items in order exceeds warehouse stock");
}
}
}
Order order = new Order
{
Id = viewModel.Id,
CanceledAt = viewModel.CanceledAt,
CompletedAt = viewModel.CompletedAt,
CreatedAt = viewModel.CreatedAt,
DeliveredAt = viewModel.DeliveredAt,
ShippedAt = viewModel.ShippedAt
};
switch (viewModel.Status)
{
case "Canceled":
order.CanceledAt = now;
break;
case "Completed":
order.CompletedAt = now;
break;
case "Delivered":
order.DeliveredAt = now;
break;
case "Shipped":
order.ShippedAt = now;
break;
}
if (viewModel.SelectedItems != null)
{
foreach (OrderElement element in viewModel.SelectedItems)
{
bool amountChanged = false;
int amountDifference = 0;
OrderElement orderElement = db.OrderElements.SingleOrDefault(o => o.Id == element.Id);
if (orderElement != null)
{
if (element.Quantity != orderElement.Quantity)
{
amountChanged = true;
amountDifference = element.Quantity - orderElement.Quantity;
}
orderElement.Quantity = element.Quantity;
db.Entry(orderElement).State = EntityState.Modified;
}
else
{
amountChanged = true;
amountDifference = element.Quantity;
orderElement = new OrderElement
{
ItemName = element.ItemName,
Quantity = element.Quantity,
OrderId = viewModel.Id
};
db.OrderElements.Add(orderElement);
}
Item affectedItemInWarehouse = db.Items.SingleOrDefault(i => i.Name == orderElement.ItemName);
if (affectedItemInWarehouse != null)
{
if (order.Status == Order.OrderStatus.Canceled)
{
affectedItemInWarehouse.QuantityInStock += orderElement.Quantity;
db.Entry(affectedItemInWarehouse).State = EntityState.Modified;
}
else
if (amountChanged == true)
{
affectedItemInWarehouse.QuantityInStock -= amountDifference;
db.Entry(affectedItemInWarehouse).State = EntityState.Modified;
}
}
}
}
db.Entry(order).State = EntityState.Modified;
db.SaveChanges();
return("OK");
}
// GET: Orders
public ActionResult Index(int? page)
{
IEnumerable<OrderElement> ord = new Queue<OrderElement>();
List<OrderElement> list = new List<OrderElement>();
var order = from m in db.Orders select m;
var userId = User.Identity.GetUserId();
order = order.Where(s => s.UserId == userId);
var users = from m in dbU.UserInfoes select m;
users = users.Where(s => s.UserId == userId);
ViewBag.UserName = users.First().Firstname;
ViewBag.LastName = users.First().Lastname;
foreach (var item in order)
{
var productId = item.ProductId;
var product = dbP.SW_Product.Find(productId);
OrderElement oE = new OrderElement();
oE.Logo = product.Logo;
oE.OrderId = item.OrderId;
oE.ProductId = product.IDProduct;
oE.ProductName = product.Name;
oE.ProductPrice = product.Price;
oE.Tag = product.Tag;
oE.UserId = item.UserId;
oE.Date = item.Date;
ord=list.AsEnumerable<OrderElement>();
list.Add(oE);
}
ViewBag.list = list;
int pageSize = 5;
int pageNumber = (page ?? 1);
return View(ord.ToPagedList(pageNumber, pageSize));
}
// GET: Orders/Details/5
public ActionResult Details(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Order order = db.Orders.Find(id);
if (order == null)
{
return HttpNotFound();
}
var userId = User.Identity.GetUserId();
var users = from m in dbU.UserInfoes select m;
users = users.Where(s => s.UserId == userId);
ViewBag.UserName = users.First().Firstname;
ViewBag.LastName = users.First().Lastname;
var productId = order.ProductId;
var product = dbP.SW_Product.Find(productId);
OrderElement oE = new OrderElement();
oE.Logo = product.Logo;
oE.Image = product.Image;
oE.Description = product.Description;
oE.OrderId = order.OrderId;
oE.ProductId = product.IDProduct;
oE.ProductName = product.Name;
oE.ProductPrice = product.Price;
oE.Tag = product.Tag;
oE.UserId = order.UserId;
oE.Date = order.Date;
if (order.Type == 0)
oE.Type = "New Product";
else
oE.Type = "Licence renewal";
if (order.Status == 0)
oE.Status = "Waiting for realisation";
else if (order.Status == 1)
oE.Status = "Realised";
else
oE.Status = "Canceled";
ViewBag.oe = oE;
return View();
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as Coverage;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.FinancialResourceStatusCodes>)StatusElement.DeepCopy();
}
if (Type != null)
{
dest.Type = (Hl7.Fhir.Model.CodeableConcept)Type.DeepCopy();
}
if (PolicyHolder != null)
{
dest.PolicyHolder = (Hl7.Fhir.Model.ResourceReference)PolicyHolder.DeepCopy();
}
if (Subscriber != null)
{
dest.Subscriber = (Hl7.Fhir.Model.ResourceReference)Subscriber.DeepCopy();
}
if (SubscriberId != null)
{
dest.SubscriberId = (Hl7.Fhir.Model.Identifier)SubscriberId.DeepCopy();
}
if (Beneficiary != null)
{
dest.Beneficiary = (Hl7.Fhir.Model.ResourceReference)Beneficiary.DeepCopy();
}
if (DependentElement != null)
{
dest.DependentElement = (Hl7.Fhir.Model.FhirString)DependentElement.DeepCopy();
}
if (Relationship != null)
{
dest.Relationship = (Hl7.Fhir.Model.CodeableConcept)Relationship.DeepCopy();
}
if (Period != null)
{
dest.Period = (Hl7.Fhir.Model.Period)Period.DeepCopy();
}
if (Payor != null)
{
dest.Payor = new List <Hl7.Fhir.Model.ResourceReference>(Payor.DeepCopy());
}
if (Class != null)
{
dest.Class = new List <Hl7.Fhir.Model.Coverage.ClassComponent>(Class.DeepCopy());
}
if (OrderElement != null)
{
dest.OrderElement = (Hl7.Fhir.Model.PositiveInt)OrderElement.DeepCopy();
}
if (NetworkElement != null)
{
dest.NetworkElement = (Hl7.Fhir.Model.FhirString)NetworkElement.DeepCopy();
}
if (CostToBeneficiary != null)
{
dest.CostToBeneficiary = new List <Hl7.Fhir.Model.Coverage.CostToBeneficiaryComponent>(CostToBeneficiary.DeepCopy());
}
if (SubrogationElement != null)
{
dest.SubrogationElement = (Hl7.Fhir.Model.FhirBoolean)SubrogationElement.DeepCopy();
}
if (Contract != null)
{
dest.Contract = new List <Hl7.Fhir.Model.ResourceReference>(Contract.DeepCopy());
}
return(dest);
}
public void Add(OrderElement domain)
{
unitOfWork.OrderElemet.Add(domain.ToEntity());
unitOfWork.Save();
}
public void Update(OrderElement domain)
{
unitOfWork.OrderElemet.Update(domain.ToEntity());
unitOfWork.Save();
}
