public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var payment = operation as PaymentIn;
if (payment == null)
{
throw new NullReferenceException("payment");
}
base.FromModel(payment, pkMap);
if (payment.PaymentMethod != null)
{
this.GatewayCode = payment.PaymentMethod != null ? payment.PaymentMethod.Code : payment.GatewayCode;
}
if (payment.BillingAddress != null)
{
this.Addresses = new ObservableCollection <AddressEntity>(new AddressEntity[] { AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(payment.BillingAddress) });
}
if (payment.TaxDetails != null)
{
this.TaxDetails = new ObservableCollection <TaxDetailEntity>(payment.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
if (payment.Discounts != null)
{
this.Discounts = new ObservableCollection <DiscountEntity>(payment.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
if (payment.Transactions != null)
{
this.Transactions = new ObservableCollection <PaymentGatewayTransactionEntity>(payment.Transactions.Select(x => AbstractTypeFactory <PaymentGatewayTransactionEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
this.Status = payment.PaymentStatus.ToString();
return(this);
}
public void TryAddOrderOperation(OrderHead orderHead, int operation, string reference)
{
bool hasOp = false;
foreach (OrderOperation orderOperation in orderHead.OrderOperations)
{
if (orderOperation.Operation == operation)
{
if (orderOperation.Reference == reference ||
(orderOperation.Reference == null && reference == null))
{
hasOp = true;
}
}
}
if (!hasOp)
{
//没有找到Op，新增
RoutingDetail routingDetail = this.routingDetailMgr.LoadRoutingDetail(orderHead.Routing, operation, reference);
if (routingDetail != null)
{
OrderOperation orderOperation = this.GenerateOrderOperation(orderHead, routingDetail);
this.CreateOrderOperation(orderOperation);
}
else
{
throw new BusinessErrorException("Order.Error.RoutingDetail.Not.Found", orderHead.Routing.Code, operation.ToString(), reference);
}
}
}
void CloseOrders(IEnumerable <Order> orders)
{
foreach (Order currOrder in orders.ToList())
{
OrderOperation.CloseOrder(currOrder);
}
}
public void AddOrderOperation(OrderOperation orderOperation)
{
if (this.OrderOperations == null)
{
this.OrderOperations = new List <OrderOperation>();
this.OrderOperations.Add(orderOperation);
}
else
{
//查找Op，插入到合适位置
int position = this.OrderOperations.Count;
for (int i = 0; i < this.OrderOperations.Count; i++)
{
OrderOperation oo = this.OrderOperations[i];
if (oo.Operation > orderOperation.Operation)
{
position = i;
break;
}
//判断是否已经有相同工序号的orderOperation，如果没有才添加
if (oo.Operation == orderOperation.Operation)
{
return;
}
}
this.OrderOperations.Insert(position, orderOperation);
}
}
void AddModifyLimitOrder(int open, int slPIPS, int tp, OrderSide side)
{
open = MathPrice.RoundToDown(open);
tp = MathPrice.RoundToDown(tp);
int sl = side == OrderSide.Buy ? open - slPIPS : open + slPIPS;
List <Order> limitOrders = SelectMulti(side, OrderOperation.GetLimitOrders());
if (limitOrders.Count != 0)
{
foreach (Order currOrder in limitOrders)
{
Meta.OrderModify(currOrder.ID, open, sl, tp, currOrder.Type);
}
}
else if (SelectMulti(side, OrderOperation.GetMarketOrders()).Count == 0)
{
try
{
Meta.OrderSend(base.Symbol, OrderType.Limit, side, LotFunction(), open, sl, tp, "");
}
catch (Exception exc)
{
logger.AddMessage(exc.ToString());
}
}
}
public virtual OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
pkMap.AddPair(operation, this);
Id = operation.Id;
CreatedDate = operation.CreatedDate;
CreatedBy = operation.CreatedBy;
ModifiedDate = operation.ModifiedDate;
ModifiedBy = operation.ModifiedBy;
Comment = operation.Comment;
Currency = operation.Currency;
Number = operation.Number;
Status = operation.Status;
IsCancelled = operation.IsCancelled;
CancelledDate = operation.CancelledDate;
CancelReason = operation.CancelReason;
IsApproved = operation.IsApproved;
Sum = operation.Sum;
return(this);
}
public List <AppCrmOrderHistoryResponse> AppOrderHistory(AppCrmOrderHistoryRequest orderHistoryRequest)
{
OrderOperation op = new OrderOperation();
List <AppCrmOrderHistoryResponse> response = op.AppGetOrderHistory(orderHistoryRequest);
return(response);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var customerOrderExtension = operation as CustomerOrderExtension;
if (customerOrderExtension != null)
{
if (customerOrderExtension.Invoices != null)
{
this.Invoices = new ObservableCollection <InvoiceEntity>(customerOrderExtension.Invoices.Select(x => new InvoiceEntity().FromModel(x, pkMap)).OfType <InvoiceEntity>());
}
}
base.FromModel(operation, pkMap);
if (customerOrderExtension.Shipments != null)
{
this.Shipments = new ObservableCollection <ShipmentEntity>(customerOrderExtension.Shipments.Select(x => AbstractTypeFactory <ShipmentEntity> .TryCreateInstance().FromModel(x, pkMap)).OfType <ShipmentEntity>());
//Link shipment item with order lineItem
foreach (var shipmentItemEntity in this.Shipments.SelectMany(x => x.Items))
{
shipmentItemEntity.LineItem = this.Items.FirstOrDefault(x => x.ModelLineItem == shipmentItemEntity.ModelLineItem);
}
}
return(this);
}
public virtual OrderOperation ToModel(OrderOperation operation)
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
operation.Id = Id;
operation.CreatedDate = CreatedDate;
operation.CreatedBy = CreatedBy;
operation.ModifiedDate = ModifiedDate;
operation.ModifiedBy = ModifiedBy;
operation.Comment = Comment;
operation.Currency = Currency;
operation.Number = Number;
operation.Status = Status;
operation.IsCancelled = IsCancelled;
operation.CancelledDate = CancelledDate;
operation.CancelReason = CancelReason;
operation.IsApproved = IsApproved;
operation.Sum = Sum;
operation.ChildrenOperations = GetAllChildOperations(operation);
return(operation);
}
public override OrderOperation ToModel(OrderOperation operation)
{
var shipment = operation as Shipment;
if (shipment == null)
{
throw new ArgumentException(@"operation argument must be of type Shipment", nameof(operation));
}
if (!Addresses.IsNullOrEmpty())
{
shipment.DeliveryAddress = Addresses.First().ToModel(AbstractTypeFactory <Address> .TryCreateInstance());
}
shipment.Discounts = Discounts.Select(x => x.ToModel(AbstractTypeFactory <Discount> .TryCreateInstance())).ToList();
shipment.Items = Items.Select(x => x.ToModel(AbstractTypeFactory <ShipmentItem> .TryCreateInstance())).ToList();
shipment.InPayments = InPayments.Select(x => x.ToModel(AbstractTypeFactory <PaymentIn> .TryCreateInstance())).OfType <PaymentIn>().ToList();
shipment.Packages = Packages.Select(x => x.ToModel(AbstractTypeFactory <ShipmentPackage> .TryCreateInstance())).ToList();
shipment.TaxDetails = TaxDetails.Select(x => x.ToModel(AbstractTypeFactory <TaxDetail> .TryCreateInstance())).ToList();
base.ToModel(shipment);
operation.Sum = shipment.TotalWithTax;
return(shipment);
}
public AppCrmOrderResponse AppCreateOrder(AppCrmOrderRequest orderRequest)
{
OrderOperation oo = new OrderOperation();
AppCrmOrderResponse rs = oo.AppCreateOrder(orderRequest);
return(rs);
}
public override OrderOperation ToModel(OrderOperation operation)
{
var order = operation as CustomerOrder;
if (order == null)
{
throw new ArgumentException(@"operation argument must be of type CustomerOrder", nameof(operation));
}
order.CustomerId = CustomerId;
order.CustomerName = CustomerName;
order.StoreId = StoreId;
order.StoreName = StoreName;
order.OrganizationId = OrganizationId;
order.OrganizationName = OrganizationName;
order.EmployeeId = EmployeeId;
order.EmployeeName = EmployeeName;
order.DiscountAmount = DiscountAmount;
order.Total = Total;
order.SubTotal = SubTotal;
order.SubTotalWithTax = SubTotalWithTax;
order.ShippingTotal = ShippingTotal;
order.ShippingTotalWithTax = ShippingTotalWithTax;
order.PaymentTotal = PaymentTotal;
order.PaymentTotalWithTax = PaymentTotalWithTax;
order.FeeTotal = HandlingTotal;
order.FeeTotalWithTax = HandlingTotalWithTax;
order.DiscountTotal = DiscountTotal;
order.DiscountTotalWithTax = DiscountTotalWithTax;
order.DiscountAmount = DiscountAmount;
order.TaxTotal = TaxTotal;
order.IsPrototype = IsPrototype;
order.SubscriptionNumber = SubscriptionNumber;
order.SubscriptionId = SubscriptionId;
order.LanguageCode = LanguageCode;
order.TaxPercentRate = TaxPercentRate;
order.Discounts = Discounts.Select(x => x.ToModel(AbstractTypeFactory <Discount> .TryCreateInstance())).ToList();
order.Items = Items.Select(x => x.ToModel(AbstractTypeFactory <LineItem> .TryCreateInstance())).ToList();
order.Addresses = Addresses.Select(x => x.ToModel(AbstractTypeFactory <Address> .TryCreateInstance())).ToList();
order.Shipments = Shipments.Select(x => x.ToModel(AbstractTypeFactory <Shipment> .TryCreateInstance())).OfType <Shipment>().ToList();
order.InPayments = InPayments.Select(x => x.ToModel(AbstractTypeFactory <PaymentIn> .TryCreateInstance())).OfType <PaymentIn>().ToList();
order.TaxDetails = TaxDetails.Select(x => x.ToModel(AbstractTypeFactory <TaxDetail> .TryCreateInstance())).ToList();
order.DynamicProperties = DynamicPropertyObjectValues.GroupBy(g => g.PropertyId).Select(x =>
{
var property = AbstractTypeFactory <DynamicObjectProperty> .TryCreateInstance();
property.Id = x.Key;
property.Name = x.FirstOrDefault()?.PropertyName;
property.Values = x.Select(v => v.ToModel(AbstractTypeFactory <DynamicPropertyObjectValue> .TryCreateInstance())).ToArray();
return(property);
}).ToArray();
base.ToModel(order);
Sum = order.Total;
return(order);
}
public Scenario()
{
productOperation = new ProductOperation();
campaignOperation = new CampaignOperation();
orderOperation = new OrderOperation();
increaseTimeOperation = new IncreaseTimeOperation();
scenarioOperation = new ScenarioOperation();
}
public override OrderOperation ToModel(OrderOperation operation)
{
var shipment = operation as Shipment;
if (shipment == null)
{
throw new ArgumentException(@"operation argument must be of type Shipment", nameof(operation));
}
if (!Addresses.IsNullOrEmpty())
{
shipment.DeliveryAddress = Addresses.First().ToModel(AbstractTypeFactory <Address> .TryCreateInstance());
}
shipment.Id = Id;
shipment.CreatedDate = CreatedDate;
shipment.CreatedBy = CreatedBy;
shipment.ModifiedDate = ModifiedDate;
shipment.ModifiedBy = ModifiedBy;
shipment.Price = Price;
shipment.PriceWithTax = PriceWithTax;
shipment.DiscountAmount = DiscountAmount;
shipment.DiscountAmountWithTax = DiscountAmountWithTax;
shipment.FulfillmentCenterId = FulfillmentCenterId;
shipment.FulfillmentCenterName = FulfillmentCenterName;
shipment.OrganizationId = OrganizationId;
shipment.OrganizationName = OrganizationName;
shipment.EmployeeId = EmployeeId;
shipment.EmployeeName = EmployeeName;
shipment.ShipmentMethodCode = ShipmentMethodCode;
shipment.ShipmentMethodOption = ShipmentMethodOption;
shipment.Height = Height;
shipment.Length = Length;
shipment.Weight = Weight;
shipment.Height = Height;
shipment.Width = Width;
shipment.MeasureUnit = MeasureUnit;
shipment.WeightUnit = WeightUnit;
shipment.Length = Length;
shipment.TaxType = TaxType;
shipment.TaxPercentRate = TaxPercentRate;
shipment.TaxTotal = TaxTotal;
shipment.Total = Total;
shipment.TotalWithTax = TotalWithTax;
shipment.Discounts = Discounts.Select(x => x.ToModel(AbstractTypeFactory <Discount> .TryCreateInstance())).ToList();
shipment.Items = Items.Select(x => x.ToModel(AbstractTypeFactory <ShipmentItem> .TryCreateInstance())).ToList();
shipment.InPayments = InPayments.Select(x => x.ToModel(AbstractTypeFactory <PaymentIn> .TryCreateInstance())).OfType <PaymentIn>().ToList();
shipment.Packages = Packages.Select(x => x.ToModel(AbstractTypeFactory <ShipmentPackage> .TryCreateInstance())).ToList();
shipment.TaxDetails = TaxDetails.Select(x => x.ToModel(AbstractTypeFactory <TaxDetail> .TryCreateInstance())).ToList();
base.ToModel(shipment);
operation.Sum = shipment.TotalWithTax;
return(shipment);
}
public OrderOperation GenerateOrderOperation(OrderHead orderHead, RoutingDetail routingDetail)
{
OrderOperation orderOp = new OrderOperation();
CloneHelper.CopyProperty(routingDetail, orderOp, OrderOperationCloneFields);
orderOp.OrderHead = orderHead;
//todo UnitTime��WorkTime����
orderHead.AddOrderOperation(orderOp);
return orderOp;
}
public override OrderOperation ToModel(OrderOperation operation)
{
var orderExtended = (DemoCustomerOrder)base.ToModel(operation);
orderExtended.ConfiguredGroups =
ConfiguredGroups
.Select(x => x.ToModel(AbstractTypeFactory <DemoOrderConfiguredGroup> .TryCreateInstance()))
.ToList();
return(orderExtended);
}
public override void onTick(Tick <int> currTick)
{
try
{
spreadAnalyzer.EvaluateSpread(currTick);
ShowComment(currTick);
if (currTime.Ticks / TickHistory.tickInOneMinute == currTick.DateTime.Ticks / TickHistory.tickInOneMinute)
{
return;
}
currTime = currTick.DateTime;
ExtremumPoint.Process(Math.Max(currTick.Bid, Meta.High(this.Symbol, 1)), Math.Min(currTick.Bid, Meta.Low(this.Symbol, 1)), currTick.DateTime);
fluctuationList.Update(ExtremumPoint);
for (int i = fluctuationList.StartIndex; i < fluctuationList.EndIndex; i++)
{
Meta.ObjectMove(GetHLineName(i), 0, DateTime.Now, fluctuationList[i].AveragePrice);
}
if (!strategyTime.IsSystemON(currTick) || newsPeriod.IsNewsTime(currTick.DateTime))
{
OrderOperation.CloseAllOrders();
return;
}
//open/modify tp
AddModifyLimitOrder(fluctuationList.GetHighest(param["OpenOrderPercent"]), param["SL"], fluctuationList.GetHighest(param["TPOrderPercent"]) + spreadAnalyzer.AverageSpread, OrderSide.Sell);
AddModifyLimitOrder(fluctuationList.GetLowest(param["OpenOrderPercent"]) + spreadAnalyzer.AverageSpread, param["SL"], fluctuationList.GetLowest(param["TPOrderPercent"]), OrderSide.Buy);
ModifyMarketOrders(OrderSide.Buy, fluctuationList.GetLowest(param["TPOrderPercent"]));
ModifyMarketOrders(OrderSide.Sell, fluctuationList.GetHighest(param["TPOrderPercent"]) + spreadAnalyzer.AverageSpread);
//close limit orders
//move tp
// //check condition to close order
//int sign = fluctuationList.GetSignDistanceFromAverageInPercent(currTick.Bid);
//if (sign >= 0)
// CloseOrders(OrderSide.Buy, marketOrders);
//if (sign <= 0)
// CloseOrders(OrderSide.Sell, marketOrders);
//int peakDistanceFromAverageMinAbs = fluctuationList.GetMinDistanceFromAverageInPercent(currTick.Bid);
//if (Math.Abs(peakDistanceFromAverageMinAbs) > param["OpenOrderPercent"])
// OpenNewMarketOrder(peakDistanceFromAverageMinAbs < 0 ? OrderSide.Buy : OrderSide.Sell, marketOrders, currTick);
}
catch (HistoryNotAvailableExceptions exc)
{
return;
}
}
public OrderOperation GenerateOrderOperation(OrderHead orderHead, RoutingDetail routingDetail)
{
OrderOperation orderOp = new OrderOperation();
CloneHelper.CopyProperty(routingDetail, orderOp, OrderOperationCloneFields);
orderOp.OrderHead = orderHead;
//todo UnitTime和WorkTime计算
orderHead.AddOrderOperation(orderOp);
return(orderOp);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var shipment = operation as Shipment;
if (shipment == null)
{
throw new ArgumentException(@"operation argument must be of type Shipment", nameof(operation));
}
base.FromModel(shipment, pkMap);
//Allow to empty address
Addresses = new ObservableCollection <AddressEntity>();
if (shipment.ShippingMethod != null)
{
ShipmentMethodCode = shipment.ShippingMethod.Code;
ShipmentMethodOption = shipment.ShipmentMethodOption;
}
if (shipment.DeliveryAddress != null)
{
Addresses = new ObservableCollection <AddressEntity>(new[] { AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(shipment.DeliveryAddress) });
}
if (shipment.Items != null)
{
Items = new ObservableCollection <ShipmentItemEntity>(shipment.Items.Select(x => AbstractTypeFactory <ShipmentItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
foreach (var shipmentItem in Items)
{
shipmentItem.ShipmentId = Id;
}
}
if (shipment.Packages != null)
{
Packages = new ObservableCollection <ShipmentPackageEntity>(shipment.Packages.Select(x => AbstractTypeFactory <ShipmentPackageEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (shipment.TaxDetails != null)
{
TaxDetails = new ObservableCollection <TaxDetailEntity>(shipment.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
if (shipment.Discounts != null)
{
Discounts = new ObservableCollection <DiscountEntity>(shipment.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
Sum = shipment.TotalWithTax;
return(this);
}
public virtual OrderOperation ToModel(OrderOperation orderOperation)
{
if (orderOperation == null)
{
throw new ArgumentNullException("orderOperation");
}
orderOperation.InjectFrom(this);
orderOperation.ChildrenOperations = GetAllChildOperations(orderOperation);
return(orderOperation);
}
public virtual OrderOperation ToModel(OrderOperation operation)
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
operation.InjectFrom(this);
operation.ChildrenOperations = OperationUtilities.GetAllChildOperations(operation);
return(operation);
}
public override OrderOperation ToModel(OrderOperation operation)
{
var order2 = operation as CustomerOrder2;
if (order2 != null)
{
order2.Invoices = this.Invoices.Select(x => x.ToModel(new Invoice())).OfType <Invoice>().ToList();
}
base.ToModel(operation);
return(operation);
}
public virtual OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
pkMap.AddPair(operation, this);
this.InjectFrom(operation);
return(this);
}
public override OrderOperation ToModel(OrderOperation operation)
{
var customerOrderExtension = operation as CustomerOrderExtension;
if (customerOrderExtension != null)
{
customerOrderExtension.Invoices = this.Invoices.Select(x => x.ToModel(new Invoice())).OfType <Invoice>().ToList();
}
base.ToModel(operation);
return(operation);
}
public override OrderOperation ToModel(OrderOperation shipment)
{
var result = base.ToModel(shipment);
var shipment2 = result as ShipmentExtension;
shipment2.IsCommercial = this.IsCommercial;
shipment2.HasLoadingDock = this.HasLoadingDock;
shipment2.shipmentDate = this.shipmentDate;
shipment2.Items = this.Items.Select(x => x.ToModel(AbstractTypeFactory <ShipmentItem> .TryCreateInstance())).ToList();
return(shipment2);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var orderEx = operation as CustomerOrderEx;
if (orderEx != null && orderEx.Invoices != null)
{
Invoices = new ObservableCollection <InvoiceEntity>(orderEx.Invoices.Select(x => new InvoiceEntity().FromModel(x, pkMap)).OfType <InvoiceEntity>());
}
base.FromModel(operation, pkMap);
return(this);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
var order = operation as CustomerOrder;
if (order == null)
{
throw new ArgumentException(@"operation argument must be of type CustomerOrder", nameof(operation));
}
base.FromModel(order, pkMap);
if (order.Addresses != null)
{
Addresses = new ObservableCollection <AddressEntity>(order.Addresses.Select(x => AbstractTypeFactory <AddressEntity> .TryCreateInstance().FromModel(x)));
}
if (order.Items != null)
{
Items = new ObservableCollection <LineItemEntity>(order.Items.Select(x => AbstractTypeFactory <LineItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
if (order.Shipments != null)
{
Shipments = new ObservableCollection <ShipmentEntity>(order.Shipments.Select(x => AbstractTypeFactory <ShipmentEntity> .TryCreateInstance().FromModel(x, pkMap)).OfType <ShipmentEntity>());
//Link shipment item with order lineItem
foreach (var shipmentItemEntity in Shipments.SelectMany(x => x.Items))
{
shipmentItemEntity.LineItem = Items.FirstOrDefault(x => x.ModelLineItem == shipmentItemEntity.ModelLineItem);
}
}
if (order.InPayments != null)
{
InPayments = new ObservableCollection <PaymentInEntity>(order.InPayments.Select(x => AbstractTypeFactory <PaymentInEntity> .TryCreateInstance().FromModel(x, pkMap)).OfType <PaymentInEntity>());
}
if (order.Discounts != null)
{
Discounts = new ObservableCollection <DiscountEntity>(order.Discounts.Select(x => AbstractTypeFactory <DiscountEntity> .TryCreateInstance().FromModel(x)));
}
if (order.TaxDetails != null)
{
TaxDetails = new ObservableCollection <TaxDetailEntity>(order.TaxDetails.Select(x => AbstractTypeFactory <TaxDetailEntity> .TryCreateInstance().FromModel(x)));
}
Sum = order.Total;
return(this);
}
public override OrderOperation ToModel(OrderOperation operation)
{
var payment = operation as PaymentIn;
if (payment == null)
{
throw new ArgumentException(@"operation argument must be of type PaymentIn", nameof(operation));
}
if (!Addresses.IsNullOrEmpty())
{
payment.BillingAddress = Addresses.First().ToModel(AbstractTypeFactory <Address> .TryCreateInstance());
}
payment.Price = Price;
payment.PriceWithTax = PriceWithTax;
payment.DiscountAmount = DiscountAmount;
payment.DiscountAmountWithTax = DiscountAmountWithTax;
payment.TaxType = TaxType;
payment.TaxPercentRate = TaxPercentRate;
payment.TaxTotal = TaxTotal;
payment.Total = Total;
payment.TotalWithTax = TotalWithTax;
payment.CustomerId = CustomerId;
payment.CustomerName = CustomerName;
payment.OrganizationId = OrganizationId;
payment.OrganizationName = OrganizationName;
payment.GatewayCode = GatewayCode;
payment.Purpose = Purpose;
payment.OuterId = OuterId;
payment.Status = Status;
payment.AuthorizedDate = AuthorizedDate;
payment.CapturedDate = CapturedDate;
payment.VoidedDate = VoidedDate;
payment.IsCancelled = IsCancelled;
payment.CancelledDate = CancelledDate;
payment.CancelReason = CancelReason;
payment.Sum = Sum;
payment.Transactions = Transactions.Select(x => x.ToModel(AbstractTypeFactory <PaymentGatewayTransaction> .TryCreateInstance())).ToList();
payment.TaxDetails = TaxDetails.Select(x => x.ToModel(AbstractTypeFactory <TaxDetail> .TryCreateInstance())).ToList();
payment.Discounts = Discounts.Select(x => x.ToModel(AbstractTypeFactory <Discount> .TryCreateInstance())).ToList();
base.ToModel(payment);
payment.PaymentStatus = EnumUtility.SafeParse(Status, PaymentStatus.Custom);
return(payment);
}
public override OperationEntity FromModel(OrderOperation operation, PrimaryKeyResolvingMap pkMap)
{
base.FromModel(operation, pkMap);
var orderExtended = (DemoCustomerOrder)operation;
if (orderExtended.ConfiguredGroups != null)
{
ConfiguredGroups = new ObservableCollection <DemoOrderConfiguredGroupEntity>(
orderExtended.ConfiguredGroups.Select(x => AbstractTypeFactory <DemoOrderConfiguredGroupEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
return(this);
}
public static WebAPI.Order.Side GetSide(OrderOperation operation)
{
switch (operation)
{
case OrderOperation.Buy:
return(WebAPI.Order.Side.BUY);
case OrderOperation.Sell:
return(WebAPI.Order.Side.SELL);
default:
throw new ArgumentOutOfRangeException("operation", operation, null);
}
}
public override OperationEntity FromModel(OrderOperation shipment, PrimaryKeyResolvingMap pkMap)
{
base.FromModel(shipment, pkMap);
ShipmentExtension shipment2 = new ShipmentExtension();
shipment2 = (ShipmentExtension)shipment;
this.IsCommercial = shipment2.IsCommercial;
this.HasLoadingDock = shipment2.HasLoadingDock;
this.shipmentDate = shipment2.shipmentDate;
//if (shipment2.Items != null) {
// this.Items = new ObservableCollection<ShipmentItemEntity>(shipment2.Items.Select(x => AbstractTypeFactory<ShipmentItemEntity>.TryCreateInstance().FromModel(x, pkMap)));
//}
return(this);
}
public void ApplyDataOperation(Order currentOrder,OrderOperation operation) {
switch (operation) {
case OrderOperation.open:
OrdersContext.Current.Context.RegisterOpenOrder(currentOrder,OrdersContext.Current.SessionGUID);
break;
case OrderOperation.close:
OrdersContext.Current.Context.RegisterCloseOrder(currentOrder, OrdersContext.Current.SessionGUID);
break;
case OrderOperation.complete:
OrdersContext.Current.Context.RegisterCompleteOrder(currentOrder, OrdersContext.Current.SessionGUID);
break;
}
if ((currentOrder.OrderIsExtend||currentOrder.OrderIsFixErrorEnter) && (currentOrder.ParentOrder != null)) {
OrdersContext.Current.Context.ReloadOrder(currentOrder.ParentOrder, OrdersContext.Current.SessionGUID);
}
OrdersContext.Current.SubmitChangesCallbackError();
}
public CommentCheckWindow(Window owner, string sourceMessage, Customer sender, Order order, Product product, OrderOperation requestedOperation)
{
InitializeComponent();
Owner = owner;
m_order = order;
m_requestedOperation = requestedOperation;
tbOriginalText.IsReadOnly = true;
tbOriginalText.Text = sourceMessage;
tbAmount.Text = order.Amount.ToString();
lblPrice.Content = product.Price.ToString("C", CultureInfo.CurrentCulture);
lblMin.Content = product.MinAmount.ToString("");
tbTitle.Text = product.Title;
lblCustomer.Content = sender.GetFullName();
switch (requestedOperation)
{
case OrderOperation.Add:
rbAppendOrder.IsChecked = true;
break;
case OrderOperation.Remove:
rbRemovePosition.IsChecked = true;
break;
case OrderOperation.Decrease:
rbSkipComment.IsChecked = true;
break;
default:
throw new ArgumentOutOfRangeException("requestedOperation");
}
if (!String.IsNullOrEmpty(product.ImageFile)
&& System.IO.File.Exists(System.IO.Path.Combine(RegistrySettings.GetInstance().GalleryPath, product.ImageFile)))
{
image1.Source =
new BitmapImage(new Uri(String.Format("file://{0}",
System.IO.Path.Combine(RegistrySettings.GetInstance().GalleryPath, product.ImageFile))));
}
else
{
// set default image
image1.Source =
new BitmapImage(new Uri("pack://application:,,,/Images/default.png"));
}
}
public void AddOrderOperation(OrderOperation orderOperation)
{
if (this.OrderOperations == null)
{
this.OrderOperations = new List<OrderOperation>();
this.OrderOperations.Add(orderOperation);
}
else
{
//查找Op，插入到合适位置
int position = this.OrderOperations.Count;
for (int i = 0; i < this.OrderOperations.Count; i++)
{
OrderOperation oo = this.OrderOperations[i];
if (oo.Operation > orderOperation.Operation)
{
position = i;
break;
}
//判断是否已经有相同工序号的orderOperation，如果没有才添加
if (oo.Operation == orderOperation.Operation)
{
return;
}
}
this.OrderOperations.Insert(position, orderOperation);
}
}
public void AddOrderOperation(OrderOperation orderOperation)
{
if (this.OrderOperations == null)
{
this.OrderOperations = new List<OrderOperation>();
this.OrderOperations.Add(orderOperation);
}
else
{
//����Op�����뵽����λ��
int position = this.OrderOperations.Count;
for (int i = 0; i < this.OrderOperations.Count; i++)
{
OrderOperation oo = this.OrderOperations[i];
if (oo.Operation > orderOperation.Operation)
{
position = i;
break;
}
//�ж��Ƿ��Ѿ�����ͬ����ŵ�orderOperation�����û�в����
if (oo.Operation == orderOperation.Operation)
{
return;
}
}
this.OrderOperations.Insert(position, orderOperation);
}
}
private void rbAlwaysSkipComment_Checked(object sender, RoutedEventArgs e)
{
if (rbAlwaysSkipComment.IsChecked.HasValue && rbAlwaysSkipComment.IsChecked.Value)
{
tbAmount.IsEnabled = false;
tbAmount.IsReadOnly = true;
}
else
{
tbAmount.IsEnabled = true;
tbAmount.IsReadOnly = false;
}
m_result = Result.Accept;
m_requestedOperation = OrderOperation.Forget;
}
private void rbDecreaseOrder_Checked(object sender, RoutedEventArgs e)
{
m_result = Result.Accept;
m_requestedOperation = OrderOperation.Decrease;
tbAmount.IsEnabled = true;
tbAmount.IsReadOnly = false;
}
public virtual void CreateOrderOperation(OrderOperation entity)
{
entityDao.CreateOrderOperation(entity);
}
private void rbRemovePosition_Checked(object sender, RoutedEventArgs e)
{
if (rbRemovePosition.IsChecked.HasValue && rbRemovePosition.IsChecked.Value)
{
tbAmount.IsEnabled = false;
tbAmount.IsReadOnly = true;
}
else
{
tbAmount.IsEnabled = true;
tbAmount.IsReadOnly = false;
}
m_requestedOperation = OrderOperation.Remove;
m_result = Result.Accept;
}
public virtual void UpdateOrderOperation(OrderOperation entity)
{
entityDao.UpdateOrderOperation(entity);
}
public virtual void DeleteOrderOperation(OrderOperation entity)
{
entityDao.DeleteOrderOperation(entity);
}
