public virtual string CreateOrderByClause(QueryPartCollector queryPartCollector)
{
StringBuilder orderByClause = new StringBuilder();
if (queryPartCollector != null && queryPartCollector.OrderPartKeys != null)
{
bool isFirstElement = true;
foreach (object key in queryPartCollector.OrderPartKeys)
{
if (isFirstElement)
{
isFirstElement = false;
orderByClause.Append(" order by ");
}
else
{
orderByClause.Append(" , ");
}
OrderBase orderPart = (OrderBase)queryDescriptor.OrderParts[key];
orderByClause.Append(orderPart.ToPhrase());
orderByClause.Append(" ");
}
}
return(orderByClause.ToString());
}
protected OrderViewModelBase(OrderBase order)
{
Order = order;
NDoc = order.NDoc;
OrderStatus = order.Status;
TotalSum = order.TotalSum;
}
private static OrderBase CreateTestOrderScenario()
{
var order = new OrderBase {
OrderItems = new List <OrderItem>()
};
order.OrderItems.Add(new OrderItem
{
ItemInOrder = new ItemBase()
{
Name = "Book",
Amount = (decimal)23.8
},
Amount = 2
});
order.OrderItems.Add(new OrderItem
{
ItemInOrder = new ItemBase()
{
Name = "Wine",
Amount = (decimal)12.8
},
Amount = 6
});
return(order);
}
public AddOrderViewModel CreateAddOrderViewModel(OrderBase order)
{
var addOrderViewModel = _container.Resolve <AddOrderViewModel>(new DependencyOverride <IEnumerable <OrderViewModelBase> >(new List <OrderViewModelBase>()));
addOrderViewModel.SelectedOrder = _orderViewModelFactory.CreateOrderViewModel(order);
return(addOrderViewModel);
}
public OrderControllerTestsBase()
{
_mediator = new Mock <IMediator>();
_orderController = new OrderController(_mediator.Object);
_orderedItems = new List <OrderedItems>
{
new OrderedItems {
ProductType = ProductType.Calendar.ToString(), Quantity = 1
},
new OrderedItems {
ProductType = ProductType.Canvas.ToString(), Quantity = 2
}
};
_orderBase = new OrderBase
{
Id = _orderId,
RequiredBinWidth = _requiredBinWidth
};
_order = new Order
{
Id = _orderId,
CreatedOn = DateTime.Now,
RequiredBinWidth = _requiredBinWidth,
OrderItems = new List <OrderItem>()
};
_listOfOrders = new List <Order> {
_order
};
_emptyListOfOrders = new List <Order>();
}
public static OrderBase SetMessageLines(this OrderBase order, IOrderMessageLines orderMessageLines)
{
order.MessageLine1 = orderMessageLines.MessageLine1;
order.MessageLine2 = orderMessageLines.MessageLine2;
order.MessageLine3 = orderMessageLines.MessageLine3;
return(order);
}
public OrderBase CalcOrderPercentDiscount(OrderBase order)
{
var now = DateTime.Now;
var activePercentDiscount = _percentDiscountRepository.AsQuery()
.SingleOrDefault(p => p.FromDate <= now &&
p.ToDate >= now &&
p.FromTime <= now.TimeOfDay &&
p.ToTime >= now.TimeOfDay);
if (activePercentDiscount == null)
{
return(order);
}
var productDiscountCount = 0;
foreach (var orderItem in order.OrderItems)
{
var isExist = activePercentDiscount.ProductDiscounts.SingleOrDefault(item =>
item.Product.Id == orderItem.OrderProduct.ProductId);
if (isExist != null)
{
++productDiscountCount;
}
}
if (productDiscountCount > 1)
{
throw new DomainException("تعداد کالاهای این تخفیف بیشتر از یک می باشد");
}
return(order);
}
public async Task UpdateOrderAsync(OrderBase updatedOrder)
{
var partitionKey = OrderEntity.GeneratePartitionKey(updatedOrder.TraderId);
var rowKey = OrderEntity.GenerateRowKey(updatedOrder.Id);
var oldStatus = OrderStatus.Registered;
await _tableStorage.ReplaceAsync(partitionKey, rowKey, itm =>
{
oldStatus = itm.GetOrder().Status;
itm.SetOrder(updatedOrder);
return(itm);
});
if (oldStatus == updatedOrder.Status)
{
await _tableStorage.ReplaceAsync(OrderEntity.GeneratePartitionAsAllOrders(oldStatus), rowKey, itm =>
{
itm.SetOrder(updatedOrder);
return(itm);
});
return;
}
partitionKey = OrderEntity.GeneratePartitionAsAllOrders(oldStatus);
await _tableStorage.DeleteAsync(partitionKey, rowKey);
var newEntity = OrderEntity.Create(updatedOrder);
await _tableStorage.InsertOrReplaceAsync(newEntity);
}
private OrderViewModelBase CreateOrderViewModel(OrderBase order, string name)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
OrderViewModelBase orderViewModel;
if (order is BuyerOrder)
{
orderViewModel = _container.Resolve <BuyerOrderViewModel>(new DependencyOverride <BuyerOrder>(order));
}
else if (order is SupplierOrder)
{
orderViewModel = _container.Resolve <SupplierOrderViewModel>(new DependencyOverride <SupplierOrder>(order));
}
else
{
throw new NotSupportedException($"{order.GetType().Name} is not supported");
}
orderViewModel.Name = name;
return(orderViewModel);
}
private Output isChanged(bool isBuy, OrderBase orderAddRemove)
{
if (isBuy)
{
double? newIncomeFromSelling = _buyLinkedList.calculateExpense();
//Debug.WriteLine("{0} IncomeFromSelling: {1}", orderAddRemove.TimeStamp, newIncomeFromSelling);
if (!Test.areDoublesEqual(_incomeFromSelling.Total, newIncomeFromSelling))
{
_incomeFromSelling.Timestamp = orderAddRemove.TimeStamp;
_incomeFromSelling.Total = newIncomeFromSelling;
return _incomeFromSelling;
}
}
else
{
double? newExpenseBuying = _sellLinkedList.calculateExpense();
//Debug.WriteLine("{0} ExpenseBuying: {1}", orderAddRemove.TimeStamp, newExpenseBuying);
if (!Test.areDoublesEqual(_expenseBuying.Total, newExpenseBuying))
{
_expenseBuying.Timestamp = orderAddRemove.TimeStamp;
_expenseBuying.Total = newExpenseBuying;
return _expenseBuying;
}
}
return null;
}
private void EditingBlock_OrderAdded(OrderBase order)
{
OrderItemEditorView editorView = new OrderItemEditorView(order);
editorViewDict.Add(order, editorView);
OrderEditorViewContext.Children.Add(editorView);
}
private async Task HandleCommonStuff(OrderBase order)
{
var id = await _identityGenerator.GenerateNewIdAsync();
order.Id = id;
order.Status = OrderStatus.Registered;
order.Registered = DateTime.UtcNow;
}
private OrderType GetOrderType(OrderBase orderBase)
{
if (orderBase is PrivateOrder)
{
return(OrderType.PrivateOrder);
}
return(OrderType.AreaOrder);
}
/// <summary>
/// Creates new instance of the <see cref="AdvancedOrderBase"/> class.
/// </summary>
/// <param name="baseOrder">Base order object for creating advanced one.</param>
/// <param name="orderClass">Advanced order class for new smart order.</param>
protected internal AdvancedOrderBase(
OrderBase baseOrder,
OrderClass orderClass)
: base(baseOrder.EnsureNotNull(nameof(baseOrder)))
{
BaseOrder = baseOrder;
OrderClass = orderClass;
}
internal AdvancedOrderBase(
OrderBase baseOrder,
OrderClass orderClass)
: base(baseOrder)
{
BaseOrder = baseOrder;
OrderClass = orderClass;
}
public async Task RegisterOrderAsync(OrderBase order)
{
var newEntity = OrderEntity.Create(order);
await _tableStorage.InsertAsync(newEntity);
newEntity.PartitionKey = OrderEntity.GeneratePartitionKey(order.TraderId);
await _tableStorage.InsertAsync(newEntity);
}
public async Task <GetOrderDto> GetCurrentByAccountIdAsync(long accountId, CancellationToken ct = default)
{
_logger.LogInformation("Get current order by AccountId, {AccountId}", accountId);
OrderBase currentOrder = await GetCurrentOrderAsync(accountId, ct);
return(_mapper.Map <GetOrderDto>(currentOrder));
}
public static OrderBase SetExchangeRate(this OrderBase order, Customer customer, decimal exchangeRate)
{
if (customer.IsForeignCurrencyAccount && exchangeRate > 0)
{
order.ExchangeRate = (double)exchangeRate;
}
return(order);
}
private void OrderStatusHandler(OrderBase order)
{
// Do something for handle order status changing.
Console.WriteLine($"Order {order.OrigClientId} is {order.Status}");
// Use OrigClientId for comparison of orders.
}
public void CreateOrder3()
{
OrderBase order = PromotionTests.CreateOrder3();
Assert.AreEqual(order.Products.ToList().Sum(p => p.DiscountedPrice), 280);
// Assert.Fail();
}
public ShopOrderLog(Guid id, Shop shop, OrderBase order)
{
Id = id;
Shop = shop;
Order = order;
CreationTime = DateTime.Now;
HasSuggestions = false;
HasFactor = false;
}
public OrderItemEditorView(OrderBase order)
{
this.order = order;
InitializeComponent();
Indicator.IsCountVisible = false;
ValueEditorUtility.CreateValueEditorViews(order, ValueEditorViewContext);
}
private static OrderDetail NewOrderDetail(OrderBase order)
{
var orderLine = new OrderDetail {
TaxMode = order.TaxMode
};
order.Detail.Add(orderLine);
return(orderLine);
}
public static List <OrderBase> OrdersForCustomer(string CustomerID)
{
List <OrderBase> CustOrders = new List <OrderBase>();
OrderBase OB;
OrderDetailsBase ODB;
DataTable dtOrders = new DataTable(), dtDetails;
//get the orders
string sql = "Select * from Orders where CustomerID = @CustomerID order by OrderDate";
string sqlDet = "Select * from [Order Details] Where OrderID = @OrderID";
SqlDataAdapter da, daDet;
OpenDB();
da = new SqlDataAdapter(sql, con);
da.SelectCommand.Parameters.Add(new SqlParameter("@CustomerID", CustomerID));
da.FillSchema(dtOrders, SchemaType.Source);
da.Fill(dtOrders);
foreach (DataRow dr in dtOrders.Rows)
{
OB = new OrderBase();
OB.OrderID = (int)dr["OrderID"];
OB.CustomerID = CustomerID;
OB.OrderDate = (DateTime)dr["OrderDate"];
OB.RequiredDate = dr["RequiredDate"] != DBNull.Value ? (DateTime?)dr["RequiredDate"] : null;
OB.ShippedDate = dr["ShippedDate"] != DBNull.Value ? (DateTime?)dr["ShippedDate"] : null;
OB.EmployeeID = dr["EmployeeID"] != DBNull.Value ? (int?)dr["EmployeeID"] : null;
OB.ShipVia = dr["ShipVia"] != DBNull.Value ? (int?)dr["ShipVia"] : null;
OB.Freight = dr["Freight"] != DBNull.Value ? (decimal?)dr["Freight"] : null;
OB.ShipName = dr["ShipName"] != DBNull.Value ? (string)dr["ShipName"] : null;
OB.ShipAddress = dr["ShipAddress"] != DBNull.Value ? (string)dr["ShipAddress"] : null;
OB.ShipCity = dr["ShipCity"] != DBNull.Value ? (string)dr["ShipCity"] : null;
OB.ShipRegion = dr["ShipRegion"] != DBNull.Value ? (string)dr["ShipRegion"] : null;
OB.ShipPostalCode = dr["ShipPostalCode"] != DBNull.Value ? (string)dr["ShipPostalCode"] : null;
OB.ShipCountry = dr["ShipCountry"] != DBNull.Value ? (string)dr["ShipCountry"] : null;
//and now get all the details for the order
daDet = new SqlDataAdapter(sqlDet, con);
daDet.SelectCommand.Parameters.Add(new SqlParameter("@OrderID", OB.OrderID));
dtDetails = new DataTable(); //must make a new one or it will add on to the old one!
daDet.FillSchema(dtDetails, SchemaType.Source);
daDet.Fill(dtDetails);
OB.ListOrderDetailsBase = new List <OrderDetailsBase>();
foreach (DataRow drdet in dtDetails.Rows)
{
ODB = new OrderDetailsBase();
ODB.OrderID = OB.OrderID;
ODB.ProductID = (int)drdet["ProductID"];
ODB.UnitPrice = (decimal)drdet["UnitPrice"];
ODB.Quantity = (short)drdet["Quantity"];
ODB.Discount = (float)drdet["Discount"];
OB.ListOrderDetailsBase.Add(ODB);
}
CustOrders.Add(OB);
}
return(CustOrders);
}
public static OrderBase SetDeliveryAddress(this OrderBase order, Customer customer)
{
order.DeliverTo = new Address(
customer.PhysicalAddress.Line1.EmptyIfNull(),
customer.PhysicalAddress.Line2.EmptyIfNull(),
customer.PhysicalAddress.Line3.EmptyIfNull(),
customer.PhysicalAddress.Line4.EmptyIfNull(),
customer.PhysicalAddress.Line5.EmptyIfNull(),
customer.PhysicalAddress.Line6.EmptyIfNull());
return(order);
}
private async Task ValidateAddingGameToOrderAsync(OrderBase currentOrder, long gameId, CancellationToken ct)
{
bool isGameAlreadyExists =
await _unitOfWork.OrderGameRepository.IsExists(currentOrder.AccountId, gameId, ct);
if (isGameAlreadyExists)
{
_logger.LogInformation("Account {AccountId} already has game {GameId}", currentOrder.AccountId, gameId);
throw new AccountAlreadyHasGameException();
}
}
public string GenerateInvoice(OrderBase order)
{
if (order.OrderItems.Any())
{
foreach (var ord in order.OrderItems)
{
}
}
return(string.Empty);
}
/// <summary>
/// Обновляет объявление в базе данных по идентификатору <see cref="OrderBase.ID"/>
/// </summary>
/// <param name="id"></param>
/// <param name="order"></param>
// PUT api/order/5
public void Put(int id, ActionData actionData)
{
OrderBase order = _dbContext.OrderBases.Find(id);
order.ObjectBase.Title = actionData.orderFields[1].ToString();
order.ObjectBase.Description = actionData.orderFields[2].ToString();
order.ObjectBase.CategoryItem = _dbContext.CategoryItems.Find(actionData.orderFields[3]);
order.ObjectBase.Location = actionData.orderFields[4].ToString();
_dbContext.SaveChanges();
}
public static OrderBase SetPostalAddress(this OrderBase order, Customer customer)
{
order.InvoiceTo = new Address(
customer.PostalAddress.Line1.EmptyIfNull(),
customer.PostalAddress.Line2.EmptyIfNull(),
customer.PostalAddress.Line3.EmptyIfNull(),
customer.PostalAddress.Line4.EmptyIfNull(),
customer.PostalAddress.Line5.EmptyIfNull(),
customer.PostalAddress.Line6.EmptyIfNull());
return(order);
}
public void Delete(int id)
{
OrderBase order = _dbContext.OrderBases.Find(id);
ObjectBase obj = _dbContext.ObjectBases.Find(id);
if (order != null && obj != null)
{
_dbContext.OrderBases.Remove(order);
_dbContext.ObjectBases.Remove(obj);
_dbContext.SaveChanges();
}
}
public static OrderEntity Create(OrderBase src)
{
var result = new OrderEntity
{
PartitionKey = GeneratePartitionAsAllOrders(src.Status),
RowKey = GenerateRowKey(src.Id)
};
result.SetOrder(src);
return(result);
}
public static bool InsertOrder(OrderBase orderBase, OrderDetail detail)
{
try
{
orderBase = orderBase.PostAdd();
detail.OrderID = orderBase.ID;
detail = detail.PostAdd();
if (orderBase.ID != null && detail.ID != null)
return true;
else
return false;
}
catch (Exception ex)
{
LogHelper.Write(CommonLogger.Application, ex);
return false;
}
}
public Output removeOrder(OrderBase reduceOrder)
{
Order orderToRemove = _orderIDLkp[reduceOrder.OrderID];
OrdersLinkedList relevantList = orderToRemove.IsBuy ? _buyLinkedList : _sellLinkedList;
if (orderToRemove.Volume > reduceOrder.Volume)
{
orderToRemove.Volume -= reduceOrder.Volume;
}
else
{
relevantList.remove(orderToRemove);
_orderIDLkp.Remove(orderToRemove.OrderID);
}
return isChanged(orderToRemove.IsBuy, reduceOrder);
}
public ActionResult AddOrder()
{
string userName = System.Web.HttpContext.Current.User.Identity.Name;
if (userName != null && userName != "")
{
OrderBase orderBase = new OrderBase();
orderBase.CreateTime = DateTime.Now;
orderBase.CreaterUser = userName;
orderBase.TransferAccountNumber = Request["transferAccountNumber"].ToString();
orderBase.TransferAccountTime = DateTime.ParseExact(Request["transferAccountTime"],"yyyy-MM-dd HH:mm", CultureInfo.CurrentCulture);
orderBase.TransferMethod = Request["transferMethod"].ToString();
orderBase.TransferredAmount = Convert.ToDecimal(Request["transferAmount"].ToString());
orderBase.BeneficiaryAccountNo = Request["beneficiaryAccountNo"].ToString();
orderBase.Comments = Request["comments"].ToString();
orderBase.Source = Request["source"].ToString();
orderBase.PayerName = userName;
OrderDetail orderDetail = new OrderDetail();
//orderDetail.OrderID = orderBase.ID;
orderDetail.ProductName = Request["productName"].ToString();
orderDetail.Numbers = Convert.ToInt32(Request["ProductAccount"].ToString());
orderDetail.UnitPrice = Convert.ToDecimal(Request["originPrice"].ToString());
orderDetail.TotalPrice = Convert.ToDecimal(Request["totalPrice"].ToString());
orderDetail.PayTime = DateTime.ParseExact(Request["payTime"], "yyyy-MM-dd HH:mm", CultureInfo.CurrentCulture);
orderDetail.PayAccount = Request["payAccount"].ToString();
orderDetail.GoldAccount = Convert.ToInt64(Request["goldAccount"].ToString());
//orderDetail.PayDeviceAccount = Request["payDeviceAccount"].ToString();
orderDetail.Pay4PlayerId =Convert.ToInt64(Request["pay4PlayerId"].ToString());
bool insertStatus = PlaceOrderBiz.InsertOrder(orderBase, orderDetail);
if (insertStatus)
return Content("1");
else
return Content("0");
}
else
{
return Content("0");
}
}
public Output removeOrder(OrderBase reduceOrder)
{
Order orderToRemove = _orderIDLkp[reduceOrder.OrderID];
BinaryTree relevantBook = orderToRemove.IsBuy ? _buyBook : _sellBook;
int oldVolume = orderToRemove.Volume;
if (oldVolume > reduceOrder.Volume)
{
orderToRemove.Volume -= reduceOrder.Volume;
var node = relevantBook.Find(orderToRemove);
node.adjustExpense(oldVolume);
}
else
{
relevantBook.Remove(orderToRemove);
_orderIDLkp.Remove(orderToRemove.OrderID);
}
return isChanged(orderToRemove.IsBuy, reduceOrder, relevantBook.totalExpense());
}
private Output isChanged(bool isBuyOrder, OrderBase ord, double? newIncExp)
{
if (isBuyOrder)
{
if (!Test.areDoublesEqual(_incomeFromSelling.Total, newIncExp))
{
_incomeFromSelling.Timestamp = ord.TimeStamp;
_incomeFromSelling.Total = newIncExp;
return _incomeFromSelling;
}
}
else
{
if (!Test.areDoublesEqual(_expenseBuying.Total, newIncExp))
{
_expenseBuying.Timestamp = ord.TimeStamp;
_expenseBuying.Total = newIncExp;
return _expenseBuying;
}
}
return null;
}