public void Refresh()
{
Data.FactoryManager m = new Data.FactoryManager();
Data.Order i = m.GetOrderManager().Find(this.OrderId);
this.description = i.Description;
this.quantity = i.Quantity;
}
public int AddOrder(Models.User user, List <Models.Movie> movies)
{
MovieManager movieManager = new MovieManager();
Data.User userFind = db.Users.FirstOrDefault(x => x.Id == user.Id);
Data.Order newOrder = new Data.Order();
newOrder.OrderDate = DateTime.UtcNow;
newOrder.PaymentReceipt = true;
newOrder.ShipDate = DateTime.UtcNow;
newOrder.User = userFind;
db.Orders.Add(newOrder);
db.SaveChanges();
int orderId = newOrder.Id;
foreach (var item in movies)
{
Data.Movie movie = db.Movies.SingleOrDefault(d => d.Id == item.Id);
Data.OrderItem newOrderItem = new Data.OrderItem();
newOrderItem.Order = newOrder;
newOrderItem.Movie = movie;
newOrderItem.Quantity = 1;
db.OrderItems.Add(newOrderItem);
}
db.SaveChanges();
return(orderId);
}
public void SaveWithUser(Domain.Order order)
{
Data.Order Dorder = Mapper.DomOrder2DataOrder(order);
context.Attach(Dorder.Customer);
context.Order.Add(Dorder);
context.SaveChanges();
}
public int Insert(Data.Order order)
{
using (var connection = GetNewConnection())
{
var parameters = new DynamicParameters(order);
parameters.Output(order, x => x.OrderId);
connection.Execute(SqlInsert, parameters);
return(order.OrderId);
}
}
private void ParseHtmlDocument(HtmlDocument doc)
{
foreach (var node in doc.DocumentNode.SelectNodes("//type"))
{
var id = node.GetAttributeValue("id", "type");
var sellNode = node.ChildNodes["sell"];
var sellMin = decimal.Parse(sellNode.ChildNodes["min"].InnerText, CultureInfo.InvariantCulture);
var sellMax = decimal.Parse(sellNode.ChildNodes["max"].InnerText, CultureInfo.InvariantCulture);
var sellVolume = int.Parse(sellNode.ChildNodes["volume"].InnerText);
var buyNode = node.ChildNodes["buy"];
var buyMin = decimal.Parse(buyNode.ChildNodes["min"].InnerHtml, CultureInfo.InvariantCulture);
var buyMax = decimal.Parse(buyNode.ChildNodes["max"].InnerHtml, CultureInfo.InvariantCulture);
var buyVolume = int.Parse(sellNode.ChildNodes["volume"].InnerHtml);
var item = Program.DataBase.Items.FirstOrDefault(i => i.Id == id);
var order = Program.DataBase.Orders.FirstOrDefault(o => o.Id == id);
if (order == null)
{
order = new Data.Order();
Program.DataBase.Orders.Add(order);
}
item.Order = order;
order.Id = id;
order.Item = item;
item.Order = order;
order.LastModified = DateTime.Now;
switch (Program.regionId)
{
case "10000002":
{
order.SellMinJita = sellMin;
order.SellMaxJita = sellMax;
order.SellVolume = sellVolume;
order.BuyMinJita = buyMin;
order.BuyMaxJita = buyMax;
order.BuyVolume = buyVolume;
}
break;
default: throw new Exception("Region with id "
+ Program.regionId
+ " not found");
}
}
}
public Models.Order ToWebModel(Data.Order order)
{
return(new Models.Order
{
OrderId = order.Guid,
Products = order.Products.Select(x => new Models.Product
{
Quantity = x.Quantity,
ProductType = x.ProductType.Type
}).ToList(),
RequiredBinWidth = order.PackageWidth
});
}
public ActionResult EditMyBusLine(FormCollection fc)
{
var model = new Data.Order();
model.ID = iRequest.GetQueryInt("ID");
model.Names = fc["Names"];
model.Phone = fc["Phone"];
model.Months = TypeConverter.StrToInt(fc["Months"]);
model.PayTypeID = TypeConverter.StrToInt(fc["PayTypeID"]);
var flag = Data.OrderDB.SaveEditOrder(model);
return(Json(new { success = flag }, JsonRequestBehavior.AllowGet));
}
private IEnumerable <OrderDetail> GetDetails(Data.Order order)
{
return(order.Order_Details.Select(
o => new OrderDetail
{
Product = new Product
{
ProductId = o.Product.ProductID,
ProductName = o.Product.ProductName,
},
Quantity = o.Quantity,
UnitPrice = o.UnitPrice,
}).ToList());
}
public async Task RemoveAsync(Data.Order order)
{
foreach (var item in order.OrderItems)
{
var comic = await _context.ComicBooks.FindAsync(item.ComicBookId);
if (comic == null)
{
throw new NullReferenceException("Invalid comic book Id");
}
comic.Quantity = comic.Quantity + item.Quantity;
_context.Update(comic);
}
_context.RemoveRange(order.OrderItems);
_context.Remove(order);
await _context.SaveChangesAsync();
}
public Models.Order newOrder()
{
Models.Order order = new Models.Order();
Data.Order dOrder = new Data.Order {
customerID = order.customerID,
discount = order.discount,
address = order.address,
status = order.status,
timeStamp = order.timeStamp,
orderDate = order.orderDate
};
db.orders.Add(dOrder);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
httpCtx.Trace.Warn("Database write Error", "Cannot a new order", ex);
return(new Models.Order());
}
order.orderID = dOrder.orderID;
routeDiffs(new[] {
new {
op = "add",
data = new {
customers = new Models.Customer[0],
products = new Models.Product[0],
blobs = new Models.Blob[0],
orders = new [] {
order
}
}
}
});
return(order);
}
public ActionResult BusLineInfo(FormCollection fc)
{
var model = new Data.Order();
model.CreateTime = DateTime.Now;
model.LineID = iRequest.GetQueryInt("ID");
model.Memo = "";
model.Months = TypeConverter.StrToInt(fc["Months"]);
model.Names = fc["Names"];
model.Phone = fc["Phone"];
var linemodel = new Data.BusLine();
linemodel = Data.BusLineDB.GETBusLine(model.LineID);
model.Price = linemodel.Price;
model.States = 1;
model.UserID = umodel.ID;
model.PayTypeID = TypeConverter.StrToInt(fc["PayTypeID"]);
var flag = Data.OrderDB.AddOrder(model) > 0;
return(Json(new { success = flag }, JsonRequestBehavior.AllowGet));
}
public async Task <Data.Order> CreateOrderAsync(OrderViewModel model)
{
var order = new Data.Order()
{
Id = model.Id,
Address = model.Address,
TrackingNumber = model.TrackingNumber,
TransactionId = model.TransactionId,
TransactionType = model.TransactionType,
City = model.City,
CreatedAt = model.CreatedAt,
IsDeleted = false,
Country = model.Country,
ZipCode = model.ZipCode,
Email = model.Email,
PhoneNumber = model.PhoneNumber
};
var total = 0.0m;
var productOrders = new List <Data.ProductOrder>();
foreach (var productOrder in model.ProductOrders)
{
var product = await _productManager.GetProductById(productOrder.ProductId);
total += productOrder.Quantity * product.UnitPrice;
productOrders.Add(new Data.ProductOrder()
{
Product = product, Order = order, Id = Guid.NewGuid(), IsDeleted = false
});
}
order.Total = total;
await _orderManager.CreateOrderAsync(order);
await _productOrderManager.CreateBulkProductOrderAsync(productOrders);
return(order);
}
public async Task AddAsync(Data.Order order)
{
foreach (var item in order.OrderItems)
{
var comic = await _context.ComicBooks.FindAsync(item.ComicBookId);
if (comic == null)
{
throw new NullReferenceException("Invalid comic book Id");
}
if (comic.Quantity < item.Quantity)
{
throw new InvalidOperationException(
$"Comic book with id: {comic.Id} does not have enough items to create your order (in stock {comic.Quantity}, your order {item.Quantity})");
}
comic.Quantity = comic.Quantity - item.Quantity;
_context.Update(comic);
}
_context.Orders.Add(order);
await _context.SaveChangesAsync();
}
public static Data.Task GetTaskData(string taskId)
{
var workStep1 = new Data.Workstep
{
Station = 1,
PhysicallId = 123,
Duration = 3,
Priority = false,
StartSolution = 0
};
var workStep2 = new Data.Workstep
{
Station = 2,
PhysicallId = 456,
Duration = 4,
Priority = false,
StartSolution = 5
};
var order1 = new Data.Order
{
ReleaseDate = 0,
TargetDate = 5,
WorkstepList = new List <Data.Workstep> {
workStep1, workStep2
}
};
var order2 = new Data.Order
{
ReleaseDate = 6,
TargetDate = 10,
WorkstepList = new List <Data.Workstep> {
workStep1, workStep2
}
};
var keyFigure = new Data.KeyFigure
{
VMax = 10,
VMid = 10,
VSum = 10,
AvgProcessingTime = 10,
TotalProcessingTime = 10
};
var task = new Data.Task
{
TaskId = taskId,
Description = "Task" + taskId,
ProductionType = Data.ProductionType.LINE_PRODUCTION,
NumberOfOrders = 2,
NumberOfStations = 2,
DifficultyLevel = Data.DifficultyLevel.SIMPLE,
KeyFigure = keyFigure,
SolutionType = Data.SolutionType.OPTIMAL,
OrderList = new List <Data.Order> {
order1, order2
},
PhysicalAvailable = false
};
return(task);
}
public void Save(Domain.Order order)
{
Data.Order Dorder = Mapper.DomOrder2DataOrder(order);
context.Order.Add(Dorder);
context.SaveChanges();
}
public IActionResult Detail(Guid id)
{
Data.Order order = this._orderService.GetOrderById(id);
return(View(order));
}
public Models.Order newOrder()
{
Models.Order order = new Models.Order();
Data.Order dOrder = new Data.Order{
customerID = order.customerID,
discount = order.discount,
address = order.address,
status = order.status,
timeStamp = order.timeStamp,
orderDate = order.orderDate
};
db.orders.Add(dOrder);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
httpCtx.Trace.Warn("Database write Error", "Cannot a new order", ex);
return new Models.Order();
}
order.orderID = dOrder.orderID;
routeDiffs(new[]{
new {
op = "add",
data = new {
customers = new Models.Customer[0],
products = new Models.Product[0],
blobs = new Models.Blob[0],
orders = new [] {
order
}
}
}
});
return order;
}
public async Task <Data.Order> CreateOrderAsync(Data.Order order)
{
await _genericOrderRepository.CreateAsync(order);
return(order);
}
