public static async Task <string> BuildPdf(OrderDataModel order)
{
string template = Properties.Settings.Default.template;
if (string.IsNullOrWhiteSpace(template))
{
throw new InvalidOperationException("No se puede generar el archivo solicitado, debido a que la plantilla no está establecida.");
}
if (!File.Exists(template))
{
throw new InvalidOperationException("La plantilla para generar el arhcivo no existe, por favor, verifique la ruta al archivo.");
}
string html = File.ReadAllText(template);
html = ModeltoHtml(order, html);
string tmpDir = Path.GetTempPath();
string filename = $"{tmpDir}\\{order.ID}_{order.Customer.Firstname}{order.Customer.Lastname}.pdf";
await HTMLtoPDF(html, filename, template);
return(filename);
}
/// <summary>
/// Main method for processing Data
/// </summary>
/// <param name="Path">XML file path</param>
public void Process(string Path)
{
if (!File.Exists(Path))
{
MessageBox.Show($"File {Path} does not exist.!", "DataProcessing");
return;
}
string formattedString = FormatXml(@"C:\zadatak\zadatak.xml");
if (formattedString == string.Empty)
{
return;
}
else
{
loggerUI.LogMessage(formattedString, UIModelView.XML);
}
OrderDataModel order = DeserializeXml(@"C:\zadatak\zadatak.xml");
CalculateTotalValue(order);
loggerUI.LogMessage(ToJSON(order), UIModelView.JSON);
loggerUI.LogMessage(ToJSON(order, "Burger"), UIModelView.Filter);
}
public static OrderModelItem MapToModel(this OrderDataModel orderDataModel)
{
var orderItem = new OrderModelItem();
orderItem.Id = orderDataModel.Id;
orderItem.Date = orderDataModel.CreationDate;
orderItem.Email = orderDataModel.Email;
orderItem.UserName = $"{orderDataModel.FirstName} {orderDataModel.LastName}";
orderItem.Amount = orderDataModel.Amount;
var result = orderDataModel.PaymentId == null ? Enums.TransactionStatus.UnPaid : Enums.TransactionStatus.Paid;
orderItem.TransactionStatus = result;
orderItem.Currency = orderDataModel.OrderItems.Select(x => x.Currency).FirstOrDefault();
orderItem.OrderItems = new List <OrderItemModelItem>();
foreach (var item in orderDataModel.OrderItems)
{
orderItem.OrderItems.Add(new OrderItemModelItem
{
PrintingEditionType = item.PrintingEditionType,
Title = item.Title,
Count = item.Count
});
}
return(orderItem);
}
/// <summary>
/// 订单信息
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public OrderDataModel GetOrderData(HomeRequest request)
{
#region 查询条件
var wherePS = new Where <TbDistributionPlanInfo>();
var whereQS = new Where <TbDistributionEntOrder>();
#endregion
var retData = new OrderDataModel();
//订单信息
var orderInfo = CreatOrderInfo(request);
if (!orderInfo.Item2.Any())
{
return(retData);
}
retData = orderInfo.Item1;
//配送
wherePS.And(p => p.OrderCode.In(orderInfo.Item2));
var psList = Db.Context.From <TbDistributionPlanInfo>().Select(TbDistributionPlanInfo._.DistributionStart).Where(wherePS).ToList();
retData.Distribution = psList.Where(p => p.DistributionStart == "配送完成").Count();
retData.NotDistribution = psList.Where(p => p.DistributionStart == "未配送").Count();
//签收
whereQS.And(p => p.OrderCode.In(orderInfo.Item2));
var qsList = Db.Context.From <TbDistributionEntOrder>().Select(TbDistributionEntOrder._.All)
.LeftJoin <TbDistributionEnt>((a, c) => a.DistributionCode == c.DistributionCode)
.Where(whereQS).ToList();
retData.Sign = qsList.Where(p => p.SignState == "已签收").Count();
retData.NotSign = qsList.Where(p => p.SignState == "未签收").Count();
return(retData);
}
public OrderReviewViewModel(OrderDataModel order)
{
this.order = order;
BackCommand = new CommandHandler(o => Back(o as UserControl));
AcceptCommand = new CommandHandler(o => Accept(o as PrintDialog));
ProductSelectedCommand = new CommandHandler(i => ProductSelected((int)i));
}
/// <summary>
/// Method for calculating total Order value.
/// </summary>
/// <param name="order">Order object</param>
private void CalculateTotalValue(OrderDataModel order)
{
if (order.Item == null)
{
return;
}
order.Total = (order.Item.Sum(x => Convert.ToDecimal(x.Price) * Convert.ToDecimal(x.Quantity))
+ order.Item.Select(x => x.Modifiers).Select(y => y.Sum(t => Convert.ToDecimal(t.Price) * Convert.ToDecimal(t.Quantity))).Sum()).ToString();
}
public async Task <IActionResult> GetOrder([FromRoute] int id)
{
PutOrderDataModel data = CheackRequest();
if (data == null)
{
return(BadRequest());
}
ApplicationUser user = await GetUserWorker(data);
if (user == null)
{
return(Unauthorized());
}
var order = await _context.Orders
.Where(o => o.Id == id)
.Include(o => o.User)
.Include(o => o.Category).ThenInclude(c => c.Services)
.Include(o => o.Location).ThenInclude(l => l.District)
.Include(o => o.Location).ThenInclude(l => l.City)
.Include(o => o.OrderDetails)
.SingleOrDefaultAsync();
if (order == null)
{
return(NotFound());
}
//_context.Cities.Where(c => c.Id == order.Location.District.CityId).Load();
//_context.Services.Where(s => s.CategoryId == order.CategoryId).Load();
//_context.Categories.Where(c => c.Id == order.CategoryId).Load();
OrderDataModel dataModel = new OrderDataModel
{
Id = order.Id,
Number = order.Number,
Date = order.Date.ToString(),
CategoryName = order.Category.Name,
ClientCity = order.Location.City.Name,
ClientDistrict = order.Location.District.Name,
ClientAddress = order.Location.Address,
ClientPhone = order.User.PhoneNumber,
Description = order.Description,
OrderDetails = order.OrderDetails.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = order.TotalCost
};
return(Ok(dataModel));
}
public static int SetOrderTrackingNo(int orderId, string trackingNo)
{
OrderDataModel orderDataModel = new OrderDataModel
{
Id = orderId,
TrackingNumber = trackingNo,
Status = "Shipped"
};
string sql = @"UPDATE [dbo].[Order] SET Status=@Status, [TrackingNumber] = @TrackingNumber where Id=@Id";
return(SQLDataAccess.SaveData(sql, orderDataModel));
}
/// <summary>
/// 生成订单详情
/// </summary>
/// <param name="info"></param>
public void InitOrderDetailElment(OrderDataModel orderModel)
{
var dic = orderModel.OrderContentDic;
foreach (KeyValuePair <MaterialDataModel, int> kvp in dic)
{
var obj = ObjectManager.Instance.InstantiateObject(UIPath.PrefabPath.Order_Detail_Element);
var element = UIUtility.SafeGetComponent <OrderDetailElement>(obj.transform);
element.InitOrderDetailElement(kvp.Key, kvp.Value);
obj.transform.SetParent(OrderContent.transform, false);
}
HasInitDetailElement = true;
}
/// <summary>
/// Serialize filtered Order Object to Json format.
/// </summary>
/// <param name="order">Order object</param>
/// <param name="filter">Filtered Name of Item</param>
/// <returns></returns>
private string ToJSON(OrderDataModel order, string filter)
{
try
{
string json = JsonConvert.SerializeObject(order.Item.Where(x => x.Name.Equals(filter)), Newtonsoft.Json.Formatting.Indented);
return(json);
}
catch (Exception ex)
{
MessageBox.Show($"Error while serializing filtered JSON object.", "DataProcessing");
return("");
}
}
public HttpResponseMessage Order([FromBody] OrderDataModel orderData)
{
try
{
OrderModel objOrder = new OrderModel();
bool blnStatus = objOrder.PlaceOrder(orderData);
var response = Request.CreateResponse(blnStatus);
return(response);
}
catch (Exception)
{
throw;
}
}
public static OrderViewModel ToViewModel(this OrderDataModel orderDataModel)
{
return(new OrderViewModel
{
cheese = orderDataModel.Cheese,
comment = orderDataModel.Comment,
create_date = orderDataModel.CreateDate,
meat = orderDataModel.Meat,
rate = orderDataModel.Rate,
salad = orderDataModel.Salad,
status = Enum.GetName(typeof(OrderStatus), ((OrderStatus)orderDataModel.Status)),
total_price = orderDataModel.TotalPrice,
order_number = orderDataModel.Id
});
}
public async Task <ActionResult <WXUserOrder> > PostWXUserOrder([FromForm] OrderDataModel data)
{
//string open_id, List<ProductResultModel> productResult, decimal total_price, string order_code
System.Diagnostics.Debug.WriteLine("正在创建订单：");
System.Diagnostics.Debug.WriteLine(data.OpenId);
//foreach (var item in productResult)
//{
// WXUserOrder wXUserOrder = new WXUserOrder();
// wXUserOrder.WXUserID = open_id;
//}
WXUserOrder wXUserOrder = new WXUserOrder
{
WXUserID = data.OpenId,
TotalPrice = data.TotalPrice,
WXPayNumber = data.OrderCode,
WXUserPhone = "",
State = 1,
CreateTime = DateTime.Now
};
_context.WXUserOrder.Add(wXUserOrder);
//List<WXUserOrderDetail> OrderDetails = new List<WXUserOrderDetail>();
List <ProductResultModel> OrderDetails = JsonConvert.DeserializeObject <List <ProductResultModel> >(data.ProductResult);
System.Diagnostics.Debug.WriteLine(data.ProductResult);
System.Diagnostics.Debug.WriteLine("商品数据");
for (int i = 0; i < OrderDetails.Count(); i++)
{
System.Diagnostics.Debug.WriteLine(OrderDetails[i].ProductName);
WXUserOrderDetail wXUserOrderDetail = new WXUserOrderDetail
{
WXUserOrderID = data.OrderCode,
WXUserPhone = "",
WXProductID = OrderDetails[i].ProductID,
WXProductNumber = OrderDetails[i].ProductNumber,
};
_context.WXUserOrderDetail.Add(wXUserOrderDetail);
}
await _context.SaveChangesAsync();
//foreach(var item in wXUserOrderDetails)
//{
// CreatedAtAction("GetWXUserOrderDetail", new { id = item.ID }, item);
//}
return(CreatedAtAction("GetWXUserOrder", new { id = wXUserOrder.ID }, wXUserOrder));
}
public bool Add(OrderBLModel order)
{
OrderDataModel orderToAdd = Mapper.Map <OrderDataModel>(order);
var orderDetailsToAdd = orderToAdd.OrderDetails;
orderToAdd.OrderDetails = null;
orderToAdd.OrderDate = DateTime.Now;
_unitOfWork.OrderRepository.Create(orderToAdd);
foreach (var item in orderDetailsToAdd)
{
item.ProductId = item.Game.Id;
item.Game = null;
item.OrderId = orderToAdd.Id;
_unitOfWork.OrderDetailsRepository.Create(item);
}
return(_unitOfWork.OrderRepository.GetById(orderToAdd.Id) != null);
}
public async Task <OrderDataModel> GetOrderDataModelAsync(int orderId)
{
ApplicationUser userWorker = await GetUserWorkerAsync();
if (userWorker == null)
{
return(null);
}
WorkerSetting workerSetting = await GetWorkerSetting(userWorker);
Order order = await Context.Orders
.Include(o => o.User).Include(o => o.Location).ThenInclude(o => o.District)
.Where(o => o.Id == orderId)
.Include(o => o.OrderDetails)
.SingleOrDefaultAsync();
Context.Categories.Where(c => c.Id == order.CategoryId).Load();
Context.Services.Where(s => s.CategoryId == order.CategoryId).Load();
OrderDataModel orderDM = new OrderDataModel
{
Id = order.Id,
Number = order.Number,
Date = order.Date.ToString(),
CategoryName = order.Category.Name,
ClientCity = order.Location.City.Name,
ClientDistrict = order.Location.District.Name,
ClientAddress = order.Location.Address,
ClientPhone = order.User.PhoneNumber,
Description = order.Description,
OrderDetails = order.OrderDetails
.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = order.TotalCost
};
return(orderDM);
}
/// <summary>
/// 加工订单统计图
/// </summary>
/// <returns></returns>
public OrderDataModel GetOrderInfoReport(HomeRequest request)
{
var retData = new OrderDataModel();
//订单信息
var orderInfo = CreatOrderInfo(request);
if (!orderInfo.Item2.Any())
{
return(retData);
}
retData = orderInfo.Item1;
//配送超期
var where = new Where <TbDistributionPlanInfo>();
where.And(p => p.OrderCode.In(orderInfo.Item2));
where.And(new WhereClip("(DistributionStart='配送完成' and DATEPART(day,DeliveryCompleteTime)>DATEPART(day,DistributionTime)) or (DistributionStart='未配送' and DistributionTime>GETDATE())"));
var data = Db.Context.From <TbDistributionPlanInfo>()
.Select(TbDistributionPlanInfo._.ID, TbCompany._.ParentCompanyCode)
.LeftJoin <TbCompany>((a, c) => a.SiteCode == c.CompanyCode)
.Where(where).ToList();
retData.Distribution = data.GroupBy(p => p.ParentCompanyCode).Count();
return(retData);
}
public OrderProvider(OrderDataModel data)
{
_data = data;
}
public OrderBLModel GetOrderByOrderId(int id)
{
OrderDataModel order = _unitOfWork.OrderRepository.GetById(id);
return(Mapper.Map <OrderBLModel>(order));
}
public static int CreateNewOrder(int UserId, string Name, string CompanyName, string Address,
string City, string State, string Zip, DateTime DateCreated)
{
//Saving Order Header
OrderDataModel orderDataModel = new OrderDataModel
{
UserId = UserId,
Name = Name,
CompanyName = CompanyName,
Address = Address,
City = City,
State = State,
Zip = Zip,
DateCreated = DateCreated
};
string sql = @"INSERT INTO [dbo].[Order]
([UserId]
,[Name]
,[CompanyName]
,[Address]
,[City]
,[State]
,[Zip]
,[DateCreated])
VALUES
(@UserId
,@Name
,@CompanyName
,@Address
,@City
,@State
,@Zip
,@DateCreated)";
SQLDataAccess.SaveData(sql, orderDataModel);
OrderDataModel newOrder = GetOrder(UserId);
CartDataModel openCart = CartProcessor.GetOpenCart(UserId);
List <CartProductsDataModel> cartProducts = CartProcessor.LoadCartProducts(UserId);
//Saving order details
foreach (var product in cartProducts)
{
OrderProductsDataModel orderProducts = new OrderProductsDataModel
{
OrderId = newOrder.Id,
ProductId = product.ProductId,
ProductDescription = ProductProcessor.GetProduct(product.ProductId).Description,
ProductQty = product.ProductQty,
ProductPrice = product.ProductPrice,
ProductImagePath = ProductProcessor.GetProduct(product.ProductId).ImagePath,
ProductCode = ""
};
sql = @"INSERT INTO [dbo].[OrderProducts]
([OrderId]
,[ProductId]
,[ProductCode]
,[ProductDescription]
,[ProductImagePath]
,[ProductQty]
,[ProductPrice])
VALUES
(@OrderId
,@ProductId
,@ProductCode
,@ProductDescription
,@ProductImagePath
,@ProductQty
,@ProductPrice)";
SQLDataAccess.SaveData(sql, orderProducts);
}
//Closing user cart
CartProcessor.CloseCart(UserId);
return(newOrder.Id);
}
public async Task <GenericModel <OrderDataModel> > GetAllOrdersAsync(FilterOrderModel filter, long userId)
{
var responseModel = new GenericModel <OrderDataModel>();
var columnSql = $"oi.Id, oi.Count, pe.Id, pe.Title, pe.PrintingEditionType, o.Id, o.CreationDate, o.Amount, pa.Id, pa.TransactionId, u.Id, u.FirstName, u.LastName, u.Email";
var searchUserSql = string.Empty;
var offsetSql = string.Empty;
var sort = string.Empty;
var orderSql = string.Empty;
var transactionSql = string.Empty;
if (userId > 1)
{
searchUserSql = $@"AND o.UserId = @userId";
}
if (filter.TransactionStatus.Equals(TransactionStatus.Paid))
{
transactionSql = $"AND pa.TransactionId IS NOT NULL ";
}
if (filter.TransactionStatus.Equals(TransactionStatus.UnPaid))
{
transactionSql = $"AND pa.TransactionId IS NULL ";
}
var sortType = $"Id";
if (filter.SortType.Equals(SortType.Amount))
{
sortType = $"Amount";
}
if (filter.SortType.Equals(SortType.Date))
{
sortType = $"CreationDate";
}
var filterTypeSql = $"o.{sortType}";
if (filter.SortState.Equals(SortState.Asc))
{
sort = "ASC";
}
if (filter.SortState.Equals(SortState.Desc))
{
sort = "DESC";
}
var countBuilder = new StringBuilder($@"
SELECT COUNT(DISTINCT o.Id)
FROM OrderItems AS oi
INNER JOIN PrintingEditions AS pe ON pe.Id = oi.PrintingEditionId
INNER JOIN (
SELECT o.Id, o.CreationDate, o.Amount, o.UserId, o.PaymentId
FROM Orders AS o
INNER JOIN Payments AS pa ON o.PaymentId = pa.Id
WHERE o.IsRemoved = 0 {transactionSql} {searchUserSql} " );
var endSql = $@"
) AS o ON o.Id = oi.OrderId
INNER JOIN Payments AS pa ON pa.Id = o.PaymentId
INNER JOIN AspNetUsers AS u ON u.Id = o.UserId;";
var mainBuilder = new StringBuilder(countBuilder.ToString().Replace("COUNT(DISTINCT o.Id)", columnSql));
orderSql = $@"ORDER BY {filterTypeSql} {sort}
OFFSET (@Page - 1) * @PageSize ROWS FETCH NEXT @PageSize ROWS ONLY";
var resultSql = mainBuilder.Append(orderSql)
.Append(endSql)
.Append(countBuilder.Append(endSql).ToString()).ToString();
var orders = new List <OrderDataModel>();
using (var connection = GetSqlConnection())
{
var dict = new Dictionary <long, OrderDataModel>();
var result = await connection.QueryMultipleAsync(resultSql, new {
filter.Page,
filter.PageSize,
userId
});
orders = result.Read <OrderItem, PrintingEdition, Order, Payment, ApplicationUser, OrderDataModel>(
(orderItem, printingEdition, order, payment, user) =>
{
OrderDataModel model;
if (!dict.TryGetValue(order.Id, out model))
{
model = new OrderDataModel
{
Id = order.Id,
CreationDate = order.CreationDate,
Amount = order.Amount,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PaymentId = payment.TransactionId,
OrderItems = new List <OrderItemDataModel>()
};
dict.Add(model.Id, model);
}
model.OrderItems.Add(new OrderItemDataModel
{
PrintingEditionType = printingEdition.PrintingEditionType,
Count = orderItem.Count,
Title = printingEdition.Title
});
return(model);
},
splitOn: "Id")
.Distinct()
.ToList();
responseModel.CollectionCount = result.Read <int>().FirstOrDefault();
}
responseModel.Collection = orders;
return(responseModel);
}
public override void ChangeAction(BaseDataModel model)
{
_model = (OrderDataModel)model;
InitOrderReceiveElement();
}
public OrderViewModel()
{
GetItems();
Order = new OrderDataModel();
Test = new Command(Pay);
}
private static string ModeltoHtml(OrderDataModel order, string html)
{
// Order Products
string html_products = string.Empty;
foreach (OrderProductModel or in order.Cart)
{
html_products += $"<tr><td>{or.Name}</td><td>{or.Model}</td><td>${or.Price:#.##}</td><td>{or.Quantity}</td><td>${or.Total:#.##}</td><td><ul>[FLAG_SERIALS]<ul></td></tr>";
string html_serials = string.Empty;
if (or.SerialNumbers != null)
{
foreach (ProductSerialModel serial in or.SerialNumbers)
{
html_serials += $"<li>{serial.SerialNumber} | {serial.DateStart.ToShortDateString()} - {serial.DateEnd.ToShortDateString()}</li>";
}
}
html_products = html_products.Replace("[FLAG_SERIALS]", html_serials);
}
// Totals
string html_totals_header = string.Empty;
string html_totals_value = string.Empty;
foreach (OrderTotalModel t in order.OrderTotals)
{
html_totals_header += $"<th>{t.Title}</th>";
html_totals_value += $"<td>{(t.Value != 0 ? $"${t.Value:#.##}" : "N/A")}</td>";
}
var flags = new Dictionary <string, string>()
{
// Order
{ "[FLAG_DATE_EXPEDITION]", DateTime.Today.ToShortDateString() },
{ "[FLAG_FOLIO]", order.ID.ToString() },
{ "[FLAG_DATE_ORDER]", order.DateAdded.ToShortDateString() },
// Customer
{ "[FLAG_CNAME]", $"{order.Customer.Firstname} {order.Customer.Lastname}" },
{ "[FLAG_TELEPHONE]", $"{order.Customer.Telephone}" },
{ "[FLAG_EMAIL]", $"{order.Customer.Email}" },
{ "[FLAG_INVOICE]", $"{order.InvoicePrefix}{order.InvoiceNo}" },
{ "[FLAG_PAYMETHOD]", order.PaymentMethod.ToString() },
{ "[FLAG_SHIPMETHOD]", order.ShippingMethod.ToString() },
// Payment
{ "[FLAG_PAYMENT_NAME]", $"{order.PaymentAddress.Firstname} {order.PaymentAddress.Lastname}" },
{ "[FLAG_PAYMENT_COMPANY]", order.PaymentAddress.Company },
{ "[FLAG_PAYMENT_ADDRESS]", order.PaymentAddress.Address1 },
{ "[FLAG_PAYMENT_CITY]", order.PaymentAddress.City },
{ "[FLAG_PAYMENT_POSTCODE]", order.PaymentAddress.Postcode },
{ "[FLAG_PAYMENT_ZONE]", order.PaymentAddress.Zone.ToString() },
{ "[FLAG_PAYMENT_COUNTRY]", order.PaymentAddress.Country.ToString() },
// Shipping
{ "[FLAG_SHIPPING_NAME]", $"{order.ShippingAddress.Firstname} {order.ShippingAddress.Lastname}" },
{ "[FLAG_SHIPPING_COMPANY]", order.ShippingAddress.Company },
{ "[FLAG_SHIPPING_ADDRESS]", order.ShippingAddress.Address1 },
{ "[FLAG_SHIPPING_CITY]", order.ShippingAddress.City },
{ "[FLAG_SHIPPING_POSTCODE]", order.ShippingAddress.Postcode },
{ "[FLAG_SHIPPING_ZONE]", order.ShippingAddress.Zone.ToString() },
{ "[FLAG_SHIPPING_COUNTRY]", order.ShippingAddress.Country.ToString() },
// Products
{ "[FLAG_PRODS]", html_products },
// Totals
{ "[FLAG_TOTALS_HEADER]", html_totals_header },
{ "[FLAG_TOTALS_VALUE]", html_totals_value },
{ "[FLAG_IVA]", "16%" }
};
foreach (var flag in flags)
{
html = html.Replace(flag.Key, flag.Value);
}
return(html);
}
private static void BuildBody(TicketDocument ticket, OrderDataModel order)
{
CustomerModel customer = order.Customer;
ticket.TextLocationMode = TextTicketLocation.Body;
ticket.SideText("Fecha de expedición:", DateTime.Today.ToShortDateString());
ticket.SideText("Fecha de venta:", order.DateAdded.ToShortDateString());
ticket.SideText("Folio:", $"#{order.ID}");
ticket.Separator(TicketSeparator.Dash);
// Cliente
ticket.CenterText("[Datos del cliente]");
ticket.LeftText($"Nombre: {customer.Firstname} {customer.Lastname}");
if (!string.IsNullOrWhiteSpace(customer.Email))
{
ticket.LeftText($"Email: {customer.Email}");
}
ticket.Separator(TicketSeparator.Asterisk);
// Venta
ticket.CenterText("[Datos de venta]");
ticket.SideText("Método de pago:", order.PaymentMethod.ToString());
ticket.SideText("Método de envío:", order.ShippingMethod.ToString());
ticket.Separator(TicketSeparator.Blank);
ticket.Separator(TicketSeparator.Dash);
ticket.LeftText("Producto\tP/U\tCant\tTotal");
ticket.Separator(TicketSeparator.Dash);
// Productos
StringBuilder serials = new StringBuilder();
bool hasSerials = false;
foreach (OrderProductModel op in order.Cart)
{
string prod = (op.Name.Length < 8) ? op.Name.PadRight(8) : op.Name.Substring(0, 8);
ticket.LeftText($"-{prod}\t${op.Price:#.##}\t{op.Quantity}\t${op.Total:#.##}");
if (op.SerialNumbers.Count() > 0)
{
hasSerials = true;
foreach (ProductSerialModel serial in op.SerialNumbers)
{
serials
.Append($"-{prod} {serial.SerialNumber}"
.PadRight(TicketLen))
.Append($"{serial.DateStart.ToShortDateString()} {serial.DateEnd.ToShortDateString()}"
.PadRight(TicketLen));
}
}
}
if (hasSerials)
{
ticket.Separator(TicketSeparator.Dash);
// Serials
ticket.CenterText("# Serie | Garantía");
ticket.Separator(TicketSeparator.Blank);
ticket.LeftText(serials.ToString());
}
ticket.Separator(TicketSeparator.Dash);
// Totales
var orderTotals = order.OrderTotals.OrderBy(o => o.SortOrder);
foreach (OrderTotalModel ot in orderTotals)
{
ticket.RightText($"{ot.Title}: {((ot.Value != 0) ? $"{ot.Value:#.##}" : "N/A")}");
}
ticket.RightText($"IVA: 16%");
ticket.Separator(TicketSeparator.Dash);
}
public static void PrintTicket(string document_name, PrinterSettings settings, OrderDataModel order, int font_size = 8)
{
TicketDocument ticket = new TicketDocument(document_name, font_size, TicketLen)
{
Logo = Properties.Resources.logotipo
};
ticket.PrinterSettings = settings;
BuildHeader(ticket);
BuildBody(ticket, order);
BuildFooter(ticket);
ticket.Print();
}
public async Task <IActionResult> GetTable(FilterModel[] Filters, OrderDataModel OrderData, int pages)
{
#region Logging
if (Filters != null && Filters.Count() > 0)
{
string parameters = JsonConvert.SerializeObject(new { Filters, OrderData });
sql.LogAsync("Filter Applied", DateTime.Now, User.Identity.Name, parameters);
}
#endregion
StringBuilder WhereClause = new StringBuilder("WHERE ");
#region Initial Column Data
string ColumnNamesQuery = @"SELECT COLUMNS.COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'arkiv' AND COLUMN_NAME NOT IN (
SELECT [Column] FROM ColumnBlacklist
)";
IEnumerable <ColumnNameModel> ColumnNames = await sql.SelectDataAsync <ColumnNameModel>(ColumnNamesQuery).ConfigureAwait(false);
List <SelectListItem> ColumnNamesSelectList = ColumnNames.Select(x => new SelectListItem()
{
Value = x.COLUMN_NAME, Text = x.COLUMN_NAME
}).ToList();
#endregion
#region Active Directory account checking
bool ClearWhereFlag = false;
IEnumerable <ActiveModel> ActiveDirectoryGroupModel = await sql.SelectDataAsync <ActiveModel>("SELECT * FROM active").ConfigureAwait(false);
IEnumerable <string> Groups = GetUserGroups();
IEnumerable <string> SortedGroups = (from model in ActiveDirectoryGroupModel where Groups.Any(g => g == model.Group) select model.DEVI);
List <(string, object)> ParamList = new List <(string, object)>();
if (SortedGroups.Count() > 0)
{
WhereClause.Append("(");
for (int i = 0; i < SortedGroups.Count(); i++)
{
if (i < SortedGroups.Count() && i > 0)
{
WhereClause.Append(" OR ");
}
WhereClause.Append("DEVI = @DEVI" + i);
ParamList.Add(("@DEVI" + i, SortedGroups.ElementAt(i)));
}
WhereClause.Append(")");
}
else
{
ClearWhereFlag = true;
}
#endregion
#region Filtering
if (Filters.Count() > 0)
{
if (SortedGroups.Count() != 0)
{
WhereClause.Append(" AND ");
}
(string, (string, object)[])items = await GetFiltersToQueriesAsync(Filters).ConfigureAwait(false);
public async Task PostOrderAsync(string ordersUri, OrderDataModel order)
{
RESTClientService <OrderDataModel> restClientService = new RESTClientService <OrderDataModel>();
var item = await restClientService.PostAsync(ordersUri, order);
}
public OrderBLModel GetOrderByCustomerId(int id)
{
OrderDataModel order = _unitOfWork.OrderRepository.GetAll().FirstOrDefault(p => p.CustomerId == id);
return(Mapper.Map <OrderBLModel>(order));
}
/// <summary>
/// 接单信息
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private Tuple <OrderDataModel, List <string> > CreatOrderInfo(HomeRequest request)
{
#region 查询条件
var where = new Where <TbOrderProgress>();
//组织机构
if (!string.IsNullOrWhiteSpace(request.SiteCode))
{
List <string> SiteList = _WorkOrderLogic.GetCompanyWorkAreaOrSiteList(request.SiteCode, 5);
if (SiteList.Count > 0)
{
where.And(p => p.SiteCode.In(SiteList));
}
}
if (!string.IsNullOrEmpty(request.ProcessFactoryCode))
{
where.And(p => p.ProcessFactoryCode == request.ProcessFactoryCode);
}
where.And(new WhereClip("(YEAR(DistributionTime)=" + request.DayMonth.Year + " and MONTH(DistributionTime)=" + request.DayMonth.Month + ") or (DistributionTime<'" + request.DayMonth + "' and (ProcessingState!='Finishing'))"));
#endregion
var retData = new OrderDataModel();
var codeList = new List <string>();
//订单信息
var orderList = GetOverReceiveData(request);
if (orderList.Item1.Any())
{
var receiveList = orderList.Item1.Where(p => p.InsertTime.Month == request.DayMonth.Month).ToList();
retData.OrderCount = receiveList.Count;
retData.OrderTotal = receiveList.Sum(p => p.WeightTotal);
retData.TotalCount = orderList.Item1.GroupBy(p => p.ParentCompanyCode).Count();
codeList.AddRange(receiveList.Select(p => p.OrderCode).ToList());
}
if (orderList.Item2.Any())
{
var overList = orderList.Item2.Where(p => p.FinishTime.Value.Month == request.DayMonth.Month).ToList();
retData.OverTotal = overList.Sum(p => p.WeightSmallPlan);
retData.OverCount = overList.Select(p => p.OrderCode).Distinct().Count();
codeList.AddRange(overList.Select(p => p.OrderCode).ToList());
}
//计划完成
var planOrderList = Db.Context.From <TbOrderProgress>()
.Select(TbOrderProgress._.ProcessingState, TbOrderProgress._.OrderCode, TbOrderProgress._.FinishProcessingDateTime, TbOrderProgress._.DistributionTime, TbOrderProgress._.SiteCode)
.Where(where).ToList();
var orderCodeList = planOrderList.Select(p => p.OrderCode).ToList();
codeList.AddRange(orderCodeList);
var orderDetailList = Repository <TbWorkOrderDetail> .Query(p => p.OrderCode.In(orderCodeList) && p.DaetailWorkStrat == "未加工").ToList();
if (orderDetailList.Any())
{
retData.PlanCount = planOrderList.Count;
retData.PlanTotal = orderDetailList.Sum(p => p.WeightSmallPlan);
}
//未完成
retData.NotOver = planOrderList.Count(p => p.ProcessingState != "Finishing");
//滞后
codeList = codeList.Distinct().ToList();
var lag = GetLagData(orderCodeList);
retData.Lag = lag.Number;
retData.LagCount = lag.TotalCount;
retData.LagWeight = lag.TotalWeight;
return(new Tuple <OrderDataModel, List <string> >(retData, codeList));
}
public async Task <List <OrderDataModel> > GetOrdersDataModelAsync(UserInformerOption dataOption)
{
ApplicationUser userWorker = await GetUserWorkerAsync();
if (userWorker == null)
{
return(null);
}
WorkerSetting workerSetting = await GetWorkerSetting(userWorker);
List <Order> newOrders = new List <Order>();
if (dataOption == UserInformerOption.All || dataOption == UserInformerOption.New)
{
newOrders = await Context.Orders.Include(o => o.Location)
.Where(o => o.StatusId == (int)OrderStatus.Active &&
o.Location.CityId == workerSetting.CityId &&
workerSetting.DistrictIds.Contains(o.Location.DistrictId))
.Include(o => o.OrderDetails)
.ToListAsync();
}
List <Order> workOrders = new List <Order>();
if (dataOption == UserInformerOption.All || dataOption == UserInformerOption.Work)
{
workOrders = await Context.Orders
.Include(o => o.User).Include(o => o.Location)
.Where(o => o.WorkerId == userWorker.Worker.Id &&
o.StatusId == (int)OrderStatus.InProgress &&
o.Location.CityId == workerSetting.CityId)
.Include(o => o.OrderDetails)
.ToListAsync();
}
Context.Districts.Where(d => d.CityId == workerSetting.CityId).Load();
Context.Categories.Where(c => c.ParentId != null && workerSetting.CategoryIds.Contains(c.Id)).Load();
Context.Services.Where(s => workerSetting.CategoryIds.Contains(s.CategoryId)).Load();
List <OrderDataModel> orders = null;
switch (dataOption)
{
case UserInformerOption.All: orders = new List <OrderDataModel>(newOrders.Count + workOrders.Count);
foreach (var item in newOrders)
{
OrderDataModel orderDM = new OrderDataModel
{
Id = item.Id,
Number = item.Number,
Date = item.Date.ToString(),
CategoryName = item.Category.Name,
ClientCity = item.Location.City.Name,
ClientDistrict = item.Location.District.Name,
ClientAddress = item.Location.Address,
ClientPhone = item.User.PhoneNumber,
Description = item.Description,
OrderDetails = item.OrderDetails.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = item.TotalCost
};
orders.Add(orderDM);
}
foreach (var item in workOrders)
{
OrderDataModel orderDM = new OrderDataModel
{
Id = item.Id,
Number = item.Number,
Date = item.Date.ToString(),
CategoryName = item.Category.Name,
ClientCity = item.Location.City.Name,
ClientDistrict = item.Location.District.Name,
ClientAddress = item.Location.Address,
ClientPhone = item.User.PhoneNumber,
Description = item.Description,
OrderDetails = item.OrderDetails.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = item.TotalCost
};
orders.Add(orderDM);
}
break;
case UserInformerOption.New: orders = new List <OrderDataModel>(newOrders.Count);
foreach (var item in newOrders)
{
OrderDataModel orderDM = new OrderDataModel
{
Id = item.Id,
Number = item.Number,
Date = item.Date.ToString(),
CategoryName = item.Category.Name,
ClientCity = item.Location.City.Name,
ClientDistrict = item.Location.District.Name,
ClientAddress = "",
ClientPhone = "",
Description = item.Description,
OrderDetails = item.OrderDetails.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = item.TotalCost
};
orders.Add(orderDM);
}
break;
case UserInformerOption.Work: orders = new List <OrderDataModel>(workOrders.Count);
foreach (var item in workOrders)
{
OrderDataModel orderDM = new OrderDataModel
{
Id = item.Id,
Number = item.Number,
Date = item.Date.ToString(),
CategoryName = item.Category.Name,
ClientCity = item.Location.City.Name,
ClientDistrict = item.Location.District.Name,
ClientAddress = item.Location.Address,
ClientPhone = item.User.PhoneNumber,
Description = item.Description,
OrderDetails = item.OrderDetails.Select(o => new OrderDetailDataModel {
Quantity = o.Quantity, SeviceName = o.Service.Name
}).ToList(),
TotalCost = item.TotalCost
};
orders.Add(orderDM);
}
break;
}
;
return(orders);
}
