// Returns OrderInfoDTO based by content of info.txt and *.sca
private OrderInfoDTO GetInfoDTO(Dictionary <string, string> infoData, string directory)
{
var result = new OrderInfoDTO()
{
Name = infoData["name"],
Picture = $"api/image/{infoData["name"]}",
FileType = GetModelFileExtension(infoData.FirstOrDefault(x => x.Key.Equals("maket")).Value),
Info = infoData.FirstOrDefault(x => x.Key.Equals("dop-infa")).Value,
Address = infoData.FirstOrDefault(x => x.Key.Equals("adress")).Value,
TransportCompany = infoData.FirstOrDefault(x => x.Key.Equals("transport_kompany")).Value,
};
if (File.Exists($"{directory}\\ok.txt"))
{
result.HasClientAnswer = true;
var scaDir = GetScaDirectory(directory);
if (scaDir != null)
{
var scaData = ParseSca(directory);
scaData = RefactorScaData(scaData);
result.Status = scaData[0];
}
}
return(result);
}
public async Task <OrderInfoDTO> GetOrder(string id)
{
var data = await orderRepository.GetById(id);
if (data != null)
{
var order = new OrderInfoDTO
{
OrderId = data.OrderId,
DeliveryAddress = data.DeliveryAddress,
DeliveryDateTime = data.DeliveryDateTime,
PlacementDateTime = data.PlacementDateTime,
Price = data.Price,
AccountId = data.AccountId
};
int counter = 0;
var items = (await orderItemRepository.GetAll()).Where(oi => oi.OrderId.Equals(id)).ToList();
order.OrderItems = new OrderItemDTO[items.Count];
foreach (var item in items)
{
order.OrderItems[counter++] = new OrderItemDTO
{
Amount = item.Amount,
LaptopId = item.LaptopId
};
}
return(order);
}
return(null);
}
public ActionResult CreateRandomOrder(OrderInfoDTO orderInfoDTO)
{
IRestResponse <OrderResponseDTO> response = null;
var toppings = _distributedPizzaDbContext.Toppings.ToList();
BetterRandom random = new BetterRandom();
for (int i = 0; i < orderInfoDTO.NumberOfRequests; i++)
{
var orderManager = new OrderManager(toppings, random);
var order = orderManager.GenerateRandomOrder();
order.QueueType = orderInfoDTO.QueueType;
order.ReportBackToClient = orderInfoDTO.NumberOfRequests == 1;
var client = new RestClient("http://localhost/DistributedPizza.Web.Api");
var request = new RestRequest("api/orders/create", Method.POST);
request.AddHeader("Accept", "application/json");
request.RequestFormat = DataFormat.Json;
request.AddBody(order);
response = client.Execute <OrderResponseDTO>(request);
}
if (orderInfoDTO.NumberOfRequests == 1 & response != null)
{
response.Data.NumberOfRequests = orderInfoDTO.NumberOfRequests;
return(Json(response.Data));
}
else
{
return(Json(new OrderResponseDTO {
NumberOfRequests = orderInfoDTO.NumberOfRequests
}));
}
}
public ActionResult getorderdata(OrderInfoDTO orderInfoDTO)
{
var os = _distributedPizzaDbContext.Orders.Count(a => a.Status == Status.Started);
var rd = _distributedPizzaDbContext.Orders.Count(a => a.Status == Status.ReadyForDelivery);
var d = _distributedPizzaDbContext.Orders.Count(a => a.Status == Status.Delivered);
return(Json(new { OrderStarted = os, OrderReadyForDelivery = rd, OrderDelivered = d }));
}
public override Task <OrderInfoDTO> GetOrderById(RequestItem request, ServerCallContext context)
{
OrderInfoDTO order = new OrderInfoDTO();
order.OrderId = request.OrderId;
order.ProductId = Guid.NewGuid().ToString();
order.ProductName = "Grpc";
order.Price = "1250";
order.Number = 2;
return(Task.FromResult(order));
}
public StatusCodeResult DenyOrder([FromBody] OrderInfoDTO data)
{
if (SessionController.sm.ifTokenValidForEmployee(data.authToken))
{
if (EmployeeOrderQueue.denyOrder(data.orderID))
{
return(StatusCode(200));
}
//Internal Server Error
return(StatusCode(500));
}
else
{
return(StatusCode(401));
}
}
private OrderInfo ConvertOrder(OrderInfoDTO info)
{
OrderInfo order = new OrderInfo();
order.Address = info.Address;
order.AddTime = DateTime.Now;
order.Area = info.Area;
order.Buyer = info.Buyer;
order.City = info.City;
order.IntoDate = info.IntoDate;
order.IsCheck = false;
order.IsDel = false;
order.OrderDate = info.OrderDate;
order.ProName = info.ProName;
order.Province = info.Province;
order.remarks1 = info.remarks1;
order.remarks2 = info.remarks2;
order.UserID = info.UserID;
order.Use_UserID = info.Use_UserID;
order.OrderID = Border.GetMaxId();
return(order);
}
public string GetOrderQueue([FromBody] OrderInfoDTO data)
{
// validate that they are an employee and have valid token
if (SessionController.sm.ifTokenValidForEmployee(data.authToken))
{
var DTO = new OrderQueueDTO();
List <Order> queue = EmployeeOrderQueue.getOrderQueue();
foreach (var order in queue)
{
//TODO: don't pass in total from frontend
DTO.populateOrder(order.orderID, order.userID.ToString(), order.firstName, order.lastName,
order.getTotal().ToString(), order.getDate().ToString(), order.getItemsDictionary());
}
string output = JsonConvert.SerializeObject(DTO);
return(output);
}
else
{
return("");
}
}
public StatusCodeResult SubmitOrder([FromBody] OrderInfoDTO data)
{
if (SessionController.sm.ifTokenValid(data.authToken))
{
//TODO: populate and create order id
string orderID = EmployeeOrderQueue.generateOrderID();
if (orderID is null)
{
return(StatusCode(500));
}
EmployeeOrderQueue.addOrder(new Order(orderID, data.userID, data.firstName, data.lastName,
data.returnItemsAsDictionary(), data.total, DateTime.Now));
return(StatusCode(200));
}
else
{
return(StatusCode(401));
}
}
public async Task <List <OrderInfoDTO> > GetOrders(string userName)
{
var user = await userManager.FindByNameAsync(userName);
if (user != null)
{
var data = await userAccountRepository.GetUserOrders(user.Id);
var orders = new List <OrderInfoDTO>();
foreach (var pair in data)
{
var entry = await orderRepository.GetById(pair.Key);
var order = new OrderInfoDTO
{
OrderId = entry.OrderId,
DeliveryAddress = entry.DeliveryAddress,
DeliveryDateTime = entry.DeliveryDateTime,
PlacementDateTime = entry.PlacementDateTime,
Price = entry.Price,
AccountId = entry.AccountId
};
int counter = 0;
order.OrderItems = new OrderItemDTO[pair.Value.Count];
foreach (var item in pair.Value)
{
order.OrderItems[counter++] = new OrderItemDTO
{
Amount = item.Amount,
LaptopId = item.LaptopId
};
}
orders.Add(order);
}
return(orders);
}
return(null);
}
public void AddOrder(OrderInfoDTO info, List <OrderDetailDTO> details)
{
DateTime thisTime = DateTime.Now;
OrderInfo order = ConvertOrder(info);
List <TransModel> models = new List <TransModel>();
order.OrderID = Border.GetMaxId();
order.AddTime = thisTime;
order.OrderCode = CreateOrderCode(order);
models.Add(Border.CreateAddSql(order));
int detailID = BDetail.GetMaxId();
foreach (OrderDetailDTO d in details)
{
OrderDetail detail = ConvertOrderDetail(d);
detail.OrderDetailID = detailID;
detail.OrderID = order.OrderID;
detail.UpTime = thisTime;
models.Add(BDetail.CreateAddSql(detail));
detailID++;
}
DataService.DbHelperSQL.ExecuteSqlTran(models);
}
public StatusCodeResult ApproveOrder([FromBody] OrderInfoDTO data)
{
if (SessionController.sm.ifTokenValidForEmployee(data.authToken))
{
int result = EmployeeOrderQueue.approveOrder(data.orderID);
if (result == 1)
{
return(StatusCode(200));
}
else if (result == 0)
{
return(StatusCode(403));
}
else
{
//Internal Server Error
return(StatusCode(500));
}
}
else
{
return(StatusCode(401));
}
}
public IndexModule() : base(RouteDictionary.OrderBase)
{
this.RequiresAuthentication();
Get[RouteDictionary.Add] = p =>
{
UserIdentity user = (UserIdentity)Context.CurrentUser;
NavManager mgr = new NavManager();
NavInfo nav = mgr.CreateNav(Request.Path, user.Menus);
return(View[ViewDictionary.OrderAdd, nav]);
};
Get[RouteDictionary.OrderBizType] = p =>
{
ProductTypeSource pt = new ProductTypeSource();
List <BizType> types = pt.CreateBizTypes();
return(Response.AsJson(types));
};
Get[RouteDictionary.OrderProType] = p =>
{
string typeName = SiteFun.cutechar(p.name);
ProductTypeSource pt = new ProductTypeSource();
List <ProductTypeDTO> types = pt.CreateProTypes(typeName);
return(Response.AsJson(types));
};
Post[RouteDictionary.Add] = p =>
{
string buyer = Request.Form["buyer"].Value; //甲方名称
string proName = Request.Form["proName"].Value; //项目名称
string orderdate = Request.Form["orderdate"].Value; //下单日期
string intodate = Request.Form["intodate"].Value; //进场日期
string Province = Request.Form["Province"].Value; //省
string City = Request.Form["City"].Value; //市
string Area = Request.Form["Area"].Value; //区
string address = Request.Form["address"].Value; //详细地址
string selUsers = Request.Form["selUsers"].Value; //业务员
string remarks1 = Request.Form["remarks1"].Value; //付款方式
string remarks2 = Request.Form["remarks2"].Value; //备注
string json = Request.Form["data"].Value;
List <OrderDetailDTO> list = JsonHelper.ParseFromJson(json, typeof(List <OrderDetailDTO>)) as List <OrderDetailDTO>;
OrderInfoDTO info = new OrderInfoDTO();
info.Address = address;
info.Area = Area;
info.Buyer = buyer;
info.City = City;
if (!String.IsNullOrEmpty(intodate))
{
info.IntoDate = DateTime.Parse(intodate);
}
info.OrderDate = DateTime.Parse(orderdate);
info.ProName = proName;
info.Province = Province;
info.remarks1 = remarks1;
info.remarks2 = remarks2;
info.Use_UserID = Int32.Parse(selUsers);
UserIdentity user = (UserIdentity)Context.CurrentUser;
info.UserID = user.UserID;
OrderSource order = new OrderSource();
ResponseModel model = new ResponseModel();
try
{
order.AddOrder(info, list);
model.StatusCode = HttpStatusCode.OK;
}
catch (Exception ex)
{
model.StatusCode = HttpStatusCode.BadGateway;
model.Message = ex.Message;
}
return(Response.AsJson(model));
};
Get[RouteDictionary.ListGet] = p =>
{
string per = Request.Query["limit"]; //显示数量
string offset = Request.Query["offset"]; //当前记录条数
int pageSize = 10; //每页显示条数
int offsetNum = 0; //当前记录偏移量
if (!Int32.TryParse(offset, out offsetNum))
{
offsetNum = 0;
}
if (!Int32.TryParse(per, out pageSize))
{
pageSize = 10;
}
int pageNum = (offsetNum / pageSize) + 1;//当前页码
string sqlWhere = "1=1";
string buyer = Request.Query["buyer"];
if (!String.IsNullOrEmpty(buyer))
{
sqlWhere += " and Buyer like '%" + SiteFun.cutechar(buyer) + "%'";
}
string pro = Request.Query["p"];
if (!String.IsNullOrEmpty(pro))
{
sqlWhere += " and ProName like '%" + SiteFun.cutechar(pro) + "%'";
}
string user = Request.Query["u"];
int uid = 0;
if (!String.IsNullOrEmpty(user) && Int32.TryParse(user, out uid) && uid > 0)
{
sqlWhere += " and Use_UserID =" + uid;
}
OrderPageModel model = new OrderPageModel();
DataService.BLL.v_Order BOrder = new DataService.BLL.v_Order();
model.rows = BOrder.GetModelsByPage(sqlWhere, "OrderID desc", pageSize * (pageNum - 1) + 1, pageSize * pageNum);
model.total = BOrder.GetRecordCount(sqlWhere);
return(Response.AsJson(model));
};
Get[RouteDictionary.List] = p =>
{
UserIdentity user = (UserIdentity)Context.CurrentUser;
NavManager mgr = new NavManager();
NavInfo nav = mgr.CreateNav(Request.Path, user.Menus);
return(View[ViewDictionary.OrderList, nav]);
};
}
public async Task <IHttpActionResult> PostSELF_ORDERINFO([FromBody] string jsonstr)
{
if (!string.IsNullOrEmpty(jsonstr))
{
OrderInfoDTO sELF_ORDERINFODTO = JsonConvert.DeserializeObject <OrderInfoDTO>(jsonstr);
SELF_ORDERINFO sELF_ORDERINFO = await db.SELF_ORDERINFO.FirstOrDefaultAsync(p => p.ID == sELF_ORDERINFODTO.Id);
if (sELF_ORDERINFO == null)
{
return(NotFound());
}
sELF_ORDERINFO.MAIL_ADDRESS = sELF_ORDERINFODTO.ShippingAddress;
sELF_ORDERINFO.MAIL_TELNUM = sELF_ORDERINFODTO.ShippingPhone;
sELF_ORDERINFO.MAIL_SN = sELF_ORDERINFODTO.ShippingSN;
sELF_ORDERINFO.MAIL_STATE = sELF_ORDERINFODTO.ShippingStatus;
sELF_ORDERINFO.MAIL_DATE = sELF_ORDERINFODTO.ShippingTime;
sELF_ORDERINFO.MISC = sELF_ORDERINFODTO.Misc;
sELF_ORDERINFO.PAYMENT_STATE = sELF_ORDERINFODTO.PaymentStatus;
sELF_ORDERINFO.PAYMENT_TYPE = sELF_ORDERINFODTO.PaymentType;
sELF_ORDERINFO.PAYMENT_DATE = sELF_ORDERINFODTO.PaymentTime;
sELF_ORDERINFO.PAYMENT_ID = sELF_ORDERINFODTO.PaymentId;
sELF_ORDERINFO.ORDER_STATE = sELF_ORDERINFODTO.OrderStatus;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Entry(sELF_ORDERINFO).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SELF_ORDERINFOExists(sELF_ORDERINFODTO.Id))
{
return(NotFound());
}
else
{
//throw;
return(StatusCode(HttpStatusCode.NotModified));
}
}
return(StatusCode(HttpStatusCode.OK));
}
else
{
return(StatusCode(HttpStatusCode.BadRequest));
}
}
