示例#1
0
        public Order SaveOrder(Order order)
        {
            db.Orders.ApplyCurrentValues(order);
            db.SaveChanges();

            return GetOrder(order.OrderId);
        }
示例#2
0
    //public Order Fetch(SingleCriteria<Order, int> criteria)
    //{
    //    var obj = (Order)Activator.CreateInstance(typeof(Order), true);
    //    MarkOld(obj);
    //    return obj;
    //}

    public Order Update(Order obj)
    {
      if (obj.IsDeleted)
      {
        if (!obj.IsNew)
        {
          // delete data
        }
        MarkNew(obj);
      }
      else
      {
        if (obj.IsNew)
        {
          // insert data
          LoadProperty(obj, Order.IdProperty, System.Math.Abs(obj.Id));
        }
        else
        {
          // update data
        }
        MarkOld(obj);
      }
      return obj;
    }
示例#3
0
        public override void Activate(Actor self, Order order)
        {
            var enterCell = self.World.ChooseRandomEdgeCell();

            var plane = self.World.CreateActor("u2", new TypeDictionary
            {
                new LocationInit( enterCell ),
                new OwnerInit( self.Owner ),
                new FacingInit( Util.GetFacing(order.TargetLocation - enterCell, 0) ),
                new AltitudeInit( Rules.Info["u2"].Traits.Get<PlaneInfo>().CruiseAltitude ),
            });

            plane.CancelActivity();
            plane.QueueActivity(Fly.ToCell(order.TargetLocation));
            plane.QueueActivity(new CallFunc(() => plane.World.AddFrameEndTask( w =>
                {
                    var camera = w.CreateActor("camera", new TypeDictionary
                    {
                        new LocationInit( order.TargetLocation ),
                        new OwnerInit( self.Owner ),
                    });

                    camera.QueueActivity(new Wait(25 * (Info as SpyPlanePowerInfo).RevealTime));
                    camera.QueueActivity(new RemoveSelf());
                })));
            plane.QueueActivity(new FlyOffMap());
            plane.QueueActivity(new RemoveSelf());
        }
示例#4
0
    protected void lbBasicAuth_Click(object sender, EventArgs e)
    {
        string merchantId = ConfigurationManager.AppSettings["MerchantID"];
        string account = ConfigurationManager.AppSettings["Account"];
        string sharedSecret = ConfigurationManager.AppSettings["SharedSecret"];

        Merchant merchant = new Merchant(merchantId, account, sharedSecret);
        Order order = new Order("GBP", 999);
        //working
        CreditCard card = new CreditCard("MC", "5425232820001308", "0118", "Phil McCracken", "123", 1);
        //invalid
        //CreditCard card = new CreditCard("MC", "1234123412341234", "0118", "Phil McCracken", "123", 1);
        Address address = new Address("", "", "", "", "", "", "", "");
        PhoneNumbers numbers = new PhoneNumbers("", "", "", "");
        Payer payer = new Payer("Business", "test", "", "Phil", "McCracken", "", address, numbers, "", new ArrayList());

        string timestamp = Common.GenerateTimestamp();

        string autoSettle = "1";

        RealAuthTransactionResponse resp = RealAuthorisation.Auth(merchant, order, card, autoSettle, timestamp);

        lblErrorCode.Text = resp.ResultCode.ToString();
        lblResult.Text = resp.ResultMessage;
    }
        /********************************************************
        * CLASS PROPERTIES
        *********************************************************/
        /********************************************************
        * CLASS METHODS
        *********************************************************/
        /// <summary>
        /// Perform neccessary check to see if the model has been filled, appoximate the best we can.
        /// </summary>
        /// <param name="vehicle">Asset we're working with</param>
        /// <param name="order">Order class to check if filled.</param>
        public virtual OrderEvent Fill(Security vehicle, Order order)
        {
            //Default order event to return.
            var fill = new OrderEvent(order);

            try
            {
                switch (order.Type)
                {
                    case OrderType.Limit:
                        fill = LimitFill(vehicle, order);
                        break;
                    case OrderType.StopMarket:
                        fill = StopFill(vehicle, order);
                        break;
                    case OrderType.Market:
                        fill = MarketFill(vehicle, order);
                        break;
                }
            } catch (Exception err) {
                Log.Error("SecurityTransactionModel.TransOrderDirection.Fill(): " + err.Message);
            }

            return fill;
        }
 public void Context()
 {
     Product productInOrder = new Product(10m);
     Product productNotInOrder = new Product(20m);
     Coupon coupon = CreateCoupon.For(productNotInOrder).WithDiscountOf(.1m);
     _order = CreateOrder.Of(productInOrder).Apply(coupon).In(StateOf.UT);
 }
示例#7
0
        public override void Activate(Actor self, Order order)
        {
            // TODO: Reveal submarines

            // Should this play for all players?
            Sound.Play("sonpulse.aud");
        }
 /// <summary>
 /// Prepares payment form that will be sent (by user) to payment portal. Can establish a payment transaction if payment process requires it.
 /// </summary>
 /// <param name="order">Order info (id, price to be paid, ..)</param>
 /// <param name="portalLocale">Current user locale, can be send to payment portal to enforce the same.</param>
 /// <param name="urls">Urls that should be provided to payment portal to notify Storefront about success or to return back to portal. Notification is further processed by the <see cref="GetPaymentInfo"/>.</param>
 /// <param name="setupForm">Custom setup of payment method, can be <code>null</code> when no setup requested. See <see cref="CreateSetupForm"/></param>
 /// <returns>Payment form (to be send) plus optionally id of established transaction (to be stored).</returns>
 public PreparedPayment PreparePayment(Order order, string portalLocale, ReturnUrls urls, NameValueCollection setupForm)
 {
     var paymentForm = PaymentForm.Post(
         _settings.Pay ? urls.Notify : urls.Cancel,
         CreatePaymentFormFields(order, setupForm));
     return new PreparedPayment(paymentForm, EncodePriceAndStatusIntoTransaction(order.TotalPriceIncludingTax, PaymentStatus));
 }
示例#9
0
    public void changeOrderState(Order o)
    {
        int index = getOrderIndex(o);
        if (lbOrders.InvokeRequired)
        {
            this.BeginInvoke(new changeOrderStateDelegate(changeOrderState), o);
            return;
        }

        if (Program.debug)
        {
            Console.WriteLine("My index is: " + index);
            Console.WriteLine("ORDER SELECTED");
            Console.WriteLine(o);
        }

        if (OrderState.Ready == o.State)
        {
            btnNextState.Enabled = false;
            orders.RemoveAt(index);
            lbOrders.Items.RemoveAt(index);
            btnNextState.Text = btnTexts[0];
        }
        else
        {
            btnNextState.Text = btnTexts[(int)o.State];
            lbOrders.Items[index] = "[Qty: " + o.Qt + "] " + o.Description + " - " + o.State;
            orders[index] = o;
        }

        lbOrders.Refresh();
    }
        public static Order ToViewModel(this DataContracts.Orders.CustomerOrder order)
        {
            var orderViewModel = new Order();

            orderViewModel.Id = order.Id;

            foreach (var lineItem in order.Items)
            {
                orderViewModel.LineItems.Add(lineItem.ToViewModel());
            }

            orderViewModel.Number = order.Number;

            if (order.InPayments != null)
            {
                var firstPayment = order.InPayments.FirstOrDefault();
                if (firstPayment != null)
                {
                    orderViewModel.PaymentMethod = new PaymentMethod { Keyword = firstPayment.GatewayCode };
                }

                orderViewModel.PaymentId = firstPayment.Id;
            }

            if (order.Shipments != null)
            {
                var firstShipment = order.Shipments.FirstOrDefault();
                if (firstShipment != null)
                {
                    orderViewModel.ShippingMethod = new ShippingMethod { Keyword = firstShipment.ShipmentMethodCode, Price = firstShipment.Sum };
                }
            }

            return orderViewModel;
        }
示例#11
0
        public Order FindOrder(string sourceId, string customerSourceId)
        {
            if (!string.IsNullOrEmpty(sourceId))
            {
                var existingOrder = _orders.GetBySourceId(sourceId);
                if (null != existingOrder)
                {
                    if (string.IsNullOrEmpty(existingOrder.Customer?.SourceId))
                    {
                        if (!string.IsNullOrEmpty(customerSourceId))
                        {
                            existingOrder.Customer = FindCustomerBySourceId(customerSourceId);
                        }
                    }
                    return existingOrder;
                }
            }

            var order = new Order
            {
                SourceId = sourceId,
                Customer = FindCustomerBySourceId(customerSourceId)
            };
            _orders.Add(order);

            return order;
        }
        internal Response updateOrderState(Order order, params Input[] inputs)
        {
            Response response = new Response();
            Input state = inputs.Where(input => input.Name == "state").ElementAt(0);

            if (state == null || state.Value == "")
                response.Errors.Add(new Error("Order state can't be empty."));

            if (!order.isAllowableState(state.Value))
                response.Errors.Add(new Error("Order state " + state.Value + " isn't acceptable."));

            if (response.Errors.Count > 0)
                response.State = ResponseState.FAIL;
            else
            {
                order.State = state.Value;
                bool orderUpdated = order.update();

                if (orderUpdated)
                    response.State = ResponseState.SUCCESS;
                else
                {
                    response.Errors.Add(new Error("Unknown Error Happened While Updating Order State."));
                    response.State = ResponseState.FAIL;
                }
            }

            return response;
        }
示例#13
0
		public override void Activate(Actor self, Order order, SupportPowerManager manager)
		{
			base.Activate(self, order, manager);

			var wsb = self.TraitOrDefault<WithSpriteBody>();
			if (wsb != null && wsb.DefaultAnimation.HasSequence(info.GrantUpgradeSequence))
				wsb.PlayCustomAnimation(self, info.GrantUpgradeSequence);

			Game.Sound.Play(info.GrantUpgradeSound, self.World.Map.CenterOfCell(order.TargetLocation));

			foreach (var a in UnitsInRange(order.TargetLocation))
			{
				var um = a.TraitOrDefault<UpgradeManager>();
				if (um == null)
					continue;

				foreach (var u in info.Upgrades)
				{
					if (info.Duration > 0)
					{
						if (um.AcknowledgesUpgrade(a, u))
							um.GrantTimedUpgrade(a, u, info.Duration);
					}
					else
					{
						if (um.AcceptsUpgrade(a, u))
							um.GrantUpgrade(a, u, this);
					}
				}
			}
		}
示例#14
0
 public static Order StringToOrder( string str)
 {
     //		Debug.Log("string to order: "+str);
     Order ret = new Order();
     ret.skill = SkillType.noSkill; //default
     ret.endTurn = false;
     string[] splitStr = str.Split(' ');
     if(splitStr[0] == "place"){
         ret.skill = SkillType.place;
     }else if(splitStr[0] == "shoot"){
         ret.skill = SkillType.shoot;
     }else if(splitStr[0] == "build"){
         ret.skill = SkillType.build;
     }else if(splitStr[0] == "silence" || splitStr[0] == "silence."){
         ret.skill = SkillType.silence;
     }
     if(splitStr.Length > 1){ //it contains a field index
         string fStr = splitStr[1];
         int startID = fStr.IndexOf('(');
         int endID = fStr.IndexOf(')');
         int comma = fStr.IndexOf(',');
     //			Debug.Log("start: "+startID+" comma: "+comma+" end: "+endID);
     //			Debug.Log("str1: "+fStr.Substring(startID+1,comma-startID-1)+" str2: "+fStr.Substring(comma+1,endID-comma-1));
         int id1 = System.Convert.ToInt32(fStr.Substring(startID+1,comma-startID-1));
         int id2 = System.Convert.ToInt32(fStr.Substring(comma+1,endID-comma-1));
         ret.position = new FieldIndex(id1,id2);
     }
     if(splitStr[splitStr.Length-1].EndsWith(".")){
         ret.endTurn = true;
     }
     return ret;
 }
示例#15
0
 public Zombie(Vector2 pos)
 {
     this.pos = pos;
     this.playerState = PlayerState.Jump;
     this.order = Order.Follow;
     animationPlayer.PlayAnimation(G.animations["zombie"]);
 }
 public void Enqueue(Order order)
 {
     lock (OrderQueue)
     {
         OrderQueue.Enqueue(order);
     }
 }
示例#17
0
    public void GiveOrder(Order order)
    {
        switch (order.OrderType) {

        case Const.ORDER_STOP:
            if (IsMoveable()) {
                if (IsDeployable ()) {
                    CancelDeploy ();
                }
                GetComponent<Movement>().Stop ();
            }
            break;

        case Const.ORDER_MOVE_TO:
            if (IsMoveable()) {
                if (IsDeployable ()) {
                    CancelDeploy ();
                }
                GetComponent<Movement>().MoveTo (order.OrderLocation);
            }
            break;

        case Const.ORDER_DEPLOY:
            GetComponent<Movement>().Stop ();
            ((IDeployable)this).Deploy();
            break;
        }
    }
示例#18
0
        public override void Activate(Actor self, Order order, SupportPowerManager manager)
        {
            base.Activate(self, order, manager);

            var info = Info as SpawnActorPowerInfo;

            if (info.Actor != null)
            {
                self.World.AddFrameEndTask(w =>
                {
                    var location = self.World.Map.CenterOfCell(order.TargetLocation);

                    Game.Sound.Play(info.DeploySound, location);

                    if (!string.IsNullOrEmpty(info.EffectSequence) && !string.IsNullOrEmpty(info.EffectPalette))
                        w.Add(new SpriteEffect(location, w, info.EffectImage, info.EffectSequence, info.EffectPalette));

                    var actor = w.CreateActor(info.Actor, new TypeDictionary
                    {
                        new LocationInit(order.TargetLocation),
                        new OwnerInit(self.Owner),
                    });

                    if (info.LifeTime > -1)
                    {
                        actor.QueueActivity(new Wait(info.LifeTime));
                        actor.QueueActivity(new RemoveSelf());
                    }
                });
            }
        }
示例#19
0
        public void Define_rule()
        {
            var conditions = new RuleCondition[]
                {
                    Conditions.Equal((Order x) => x.Name, "JOE"),
                    Conditions.GreaterThan((Order x) => x.Amount, 10000.0m),
                };

            var consequences = new RuleConsequence[]
                {
                    Consequences.Delegate<Order>((session,x) => { _result = x; }),
                    Consequences.Delegate<Order>((session,x) => { _resultB = x; }),
                };

            _rule = new OdoyuleRule("RuleA", conditions, consequences);
            _rule2 = new OdoyuleRule("RuleB", conditions, consequences);

            conditions = new RuleCondition[]
                {
                    Conditions.Equal((Account a) => a.Name, "JOE"),
                };

            consequences = new RuleConsequence[]
                {
                    Consequences.Delegate((Session session, Account a) => { }),
                };

            _rule3 = new OdoyuleRule("RuleC", conditions, consequences);
        }
        protected override void getOrder(Order order, byte[] buf, int offset)
        {
            order.order = -1;
            order.charLength = 1;

            int firstByte = buf[offset] & 0xFF;
            if (firstByte == SINGLE_SHIFT_2 ||
                (firstByte >= FIRSTPLANE_HIGHBYTE_BEGIN &&
                 firstByte <= FIRSTPLANE_HIGHBYTE_END))
            {
                order.charLength = 2;
            }
            else if (firstByte == SINGLE_SHIFT_3)
            {
                order.charLength = 3;
            }

            if (firstByte == HIRAGANA_HIGHBYTE)
            {
                int secondByte = buf[offset + 1] & 0xFF;
                if (secondByte >= HIRAGANA_LOWBYTE_BEGIN &&
                    secondByte <= HIRAGANA_LOWBYTE_END)
                {
                    order.order = (secondByte - HIRAGANA_LOWBYTE_BEGIN);
                }
            }
        }
示例#21
0
        public void ResolveOrder(Actor self, Order order)
        {
            if (order.OrderString != "PlaceBeacon")
                return;

            var pos = self.World.Map.CenterOfCell(order.TargetLocation);

            self.World.AddFrameEndTask(w =>
            {
                if (playerBeacon != null)
                    self.World.Remove(playerBeacon);

                playerBeacon = new Beacon(self.Owner, pos, info.Duration, info.PalettePrefix);
                self.World.Add(playerBeacon);

                if (self.Owner.IsAlliedWith(self.World.RenderPlayer))
                    Game.Sound.PlayNotification(self.World.Map.Rules, null, info.NotificationType, info.Notification,
                        self.World.RenderPlayer != null ? self.World.RenderPlayer.Faction.InternalName : null);

                if (radarPings != null)
                {
                    if (playerRadarPing != null)
                        radarPings.Remove(playerRadarPing);

                    playerRadarPing = radarPings.Add(
                        () => self.Owner.IsAlliedWith(self.World.RenderPlayer),
                        pos,
                        self.Owner.Color.RGB,
                        info.Duration);
                }
            });
        }
        public void CreateDetailTransactionsForErrorCorrection(Order order, BLL.PickList picklist,
                                        Issue stvLog, int receiptPalletId, int receiptID, User user, DateTime convertedEthDate
                                        , int newItemId, int newUnitId, int newManufacturerId, decimal pickedPack
                                        , decimal Convertedpack, int confirmationStatusId, bool changeExpiryDate
                                        , DateTime? ExpiryDate, bool changeBatchNo, string batchNo)
        {
            //Load the ReceivePallet First From that we Get the Information that We need
            ReceivePallet receivePalletOriginal = new ReceivePallet();
            receivePalletOriginal.LoadByPrimaryKey(receiptPalletId);

            ReceiveDoc receiveDocOriginal = new ReceiveDoc();
            receiveDocOriginal.LoadByPrimaryKey(receivePalletOriginal.ReceiveID);

            //Load ItemUnit Detail for For ItemUnit Change;
            ItemUnit newItemUnit = new ItemUnit();
            newItemUnit.LoadByPrimaryKey(newUnitId);

              // Generate PicklistDetail With OrderDetail information
            PickListService pickListService = new PickListService();
            PickListDetail pickListDetail = pickListService.CreatePicklistDetailWithOrder(receiveDocOriginal, receivePalletOriginal, order, picklist,
                                                          pickedPack);
            // Generate IssueDoc from picklistDetail and substract the quantity from receiveDoc
            IssueService issueService = new IssueService();
            issueService.CreateIssueFromPicklist(pickListDetail, order, convertedEthDate, stvLog, user);

            if (Convertedpack > 0)
            {
                //duplicate The ReceiveDoc and ReceiptPallet
                ReceiveService receiveService = new ReceiveService();
                receiveService.CloneReceiveForErrorCorrection(confirmationStatusId, receivePalletOriginal, receiveDocOriginal
                                                                , Convertedpack, user, newItemId
                                                                , receiveDocOriginal.StoreID, receiptID
                                                                , newManufacturerId, newItemUnit, convertedEthDate,changeExpiryDate,ExpiryDate,changeBatchNo,batchNo);
            }
        }
示例#23
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "Vendor", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            inputFields[ "VPSProtocol" ] = "2.23";
            inputFields[ "TxType" ] = "CANCEL";
            inputFields[ "Vendor" ] = settings[ "Vendor" ];
            inputFields[ "VendorTxCode" ] = order.CartNumber;
            inputFields[ "VPSTxId" ] = order.TransactionInformation.TransactionId;
            inputFields[ "SecurityKey" ] = order.Properties[ "securityKey" ];

            IDictionary<string, string> responseFields = GetFields( MakePostRequest( GetMethodUrl( "CANCEL", settings ), inputFields ) );

            if ( responseFields[ "Status" ] == "OK" ) {
              apiInfo = new ApiInfo( order.TransactionInformation.TransactionId, PaymentState.Cancelled );
            } else {
              LoggingService.Instance.Log( "Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields[ "StatusDetail" ] );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Sage pay(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
示例#24
0
		public IEnumerable<Task> IncludingARelatedEntityShouldAvoidHittingTheServerTwice()
		{
			var dbname = GenerateNewDatabaseName();
			using (var documentStore = new DocumentStore {Url = Url + Port}.Initialize())
			{
				yield return documentStore.AsyncDatabaseCommands.EnsureDatabaseExistsAsync(dbname);

				var customer = new Customer {Name = "Customer #1", Id = "customer/1", Email = "*****@*****.**"};
				var order = new Order {Id = "orders/1", Note = "Hello", Customer = new DenormalizedReference {Id = customer.Id, Name = customer.Name}};
				using (var session = documentStore.OpenAsyncSession(dbname))
				{
					session.Store(customer);
					session.Store(order);
					yield return session.SaveChangesAsync();
				}

				using (var session = documentStore.OpenAsyncSession(dbname))
				{
					var query = session.Advanced.AsyncLuceneQuery<Order>()
						.Include(x => x.Customer.Id)
						.WhereEquals("Id", "orders/1")
						.ToListAsync();
					yield return query;

					Assert.AreEqual("Hello", query.Result.Item2[0].Note);

					// NOTE: this call should not hit the server 
					var load = session.LoadAsync<Customer>(customer.Id);
					yield return load;

					Assert.AreEqual(1, session.Advanced.NumberOfRequests);
				}
			}
		}
示例#25
0
文件: OrderMaint.cs 项目: Jaans/csla
    public OrderMaint(Guid orderId)
    {
      InitializeComponent();

      _order = Order.GetOrder(orderId);
      BindUI();
    }
 public OrderingFormNathan(string CustomerId, int EmployeeID, int OrderID) 
 {
     InitializeComponent();
     this.CustomerID = CustomerId;
     this.EmployeeID = EmployeeID;
     lblCustId.Text = CustomerID;
     lblEmID.Text = EmployeeID.ToString();
     Editing = true;
     OrderId = OrderID;
     lblorID.Text = OrderId.ToString();
     Order Get = Business.FindOrder(OrderId);
     Customer Cust = Business.GetCustomer((CustomerID));
     DetailsList = Business.OrderDetailList(OrderId);
     txtSDate.Text = Get.ShippedDate.ToString();
     txtRDate.Text = Get.RequiredDate.ToString();
     txtAddress.Text = Get.ShipAddress.ToString();
     txtCity.Text = Get.ShipCity.ToString();
     txtPostal.Text = Get.ShipPostalCode.ToString();
     lblFin.Text = Get.Freight.ToString();
     txtCountry.Text = Get.ShipCountry.ToString();
     txtRegion.Text = Get.ShipRegion.ToString();
     txtFax.Text = Cust.Fax.ToString();
     txtPhone.Text = Cust.Phone.ToString();
     Editing = true;
     ProductList = Business.ProductList();
     foreach (OrderDetail d in DetailsList) 
     {
         lsDetails.Items.Add(d.ProductName + " " + d.Quantity.ToString());
     }
     Test = Get;
 }
示例#27
0
       long tl_newSendOrderRequest(Order o)
       {
           last = o;
           count++;
           return 0;
 
       }
        public double RequestOrder(Order order)
        {
            bool productFoundInInvenory = false;
            double amount = 0;

            foreach (var product in Products)
            {
                foreach (var requestedProduct in order.OrderedItems)
                {
                    if (product.ProductID == requestedProduct.Key)
                    {
                        productFoundInInvenory = true;
                        if (product.Quantity >= requestedProduct.Value)
                        {
                            amount += product.PriceAfter * requestedProduct.Value;
                        }
                        else
                        {
                            throw new NotAvailableInInventoryException("The product is not available.");
                        }
                        break;
                    }
                }
            }

            if(!productFoundInInvenory)
            {
                throw new NotAvailableInInventoryException("The product is not present.");
            }

            return amount;
        }
        public void can_directly_extend_parameter_on_data_context_type()
        {
            RuleParameterProviders.Providers.Clear();
            RuleParameterProviders.Providers.Add(new DefaultRuleParameterProvider());
            RuleParameterProviders.Providers.Add(new OrderParameterProvider());

            var parameters = RuleParameterProviders.Providers.SelectMany(p => p.GetParameters(typeof(Order))).ToList();
            var order = new Order
            {
                Id = 10,
                Total = 100,
                Subtotal = 80
            };

            var idParam = parameters.Find(p => p.Name == "Id");
            Assert.NotNull(idParam);
            Assert.Equal(10, idParam.ResolveValue(order));

            var subtotalParam = parameters.Find(p => p.Name == "Subtotal");
            Assert.NotNull(subtotalParam);
            Assert.Equal(80m, subtotalParam.ResolveValue(order));

            var discountParam = parameters.Find(p => p.Name == "Discount");
            Assert.NotNull(discountParam);
            Assert.Equal(20m, discountParam.ResolveValue(order));
        }
        public override void ResolveOrder(Actor self, Order order)
        {
            base.ResolveOrder(self, order);

            if (order.OrderString == "Stop")
                self.CancelActivity();
        }
示例#31
0
 public string VoicePhraseForOrder(Actor self, Order order)
 {
     return(info.Voice);
 }
示例#32
0
 public void OnGet(int orderId)
 {
     Order = orderRepository.GetOrder(orderId);
 }
示例#33
0
 public Customer()
 {
     name     = RandomName.Generate(2);
     patience = Random.Range(30, 60);
     order    = new Order();
 }
示例#34
0
 private void OrderCreatorOnDeleteTrackedOrder(Order order)
 {
     _trackedOrders.Remove(order);
 }
示例#35
0
 private void OrderCreatorOnNewTrackedOrder(Order order)
 {
     _trackedOrders.Add(order);
 }
        public CreateOrder CreateOrder()
        {
            HttpContextBase context  = (HttpContextBase)Request.Properties["MS_HttpContext"];
            HttpRequestBase request  = context.Request;
            string          jsonText = request["data"];


            CreateOrder   createOrder   = new CreateOrder();
            GoodOrderView goodOrderView = JsonConvert.DeserializeObject <GoodOrderView>(jsonText);
            string        payway        = request["payway"];
            //string jifen = request["jifen"];
            string liuyan = request["liuyan"];

            int?           userID         = null;
            Authentication authentication = new Authentication(request);

            if (string.IsNullOrEmpty(authentication.state))
            {
                userID = authentication.userID;
            }

            bool baoyou = false;
            OrderDetailsModel orderDetailsModel = new OrderDetailsModel();
            Order             order             = new Order();

            using (Entity entity = new Entity())
            {
                foreach (var goodCartView in goodOrderView.GoodCartViewList)
                {
                    int goodChildID = goodCartView.goodChildID;
                    int num         = goodCartView.num;
                    var goodChild   = entity.GoodChild.Include("Good").Where(o => o.GoodChildID == goodChildID && o.State == 1).FirstOrDefault();
                    if (goodChild == null)
                    {
                        createOrder.error = "商品不存在或者已经下架";
                        return(createOrder);
                    }
                    if (goodChild.Repertory == 0)
                    {
                        createOrder.error = "商品库存不够";
                        return(createOrder);
                    }
                    if ((goodChild.Good.State & 32) > 0)
                    {
                        baoyou = true;
                    }
                    order.Num += num;
                    orderDetailsModel.OrderDetailModelList.Add(new OrderDetailModel()
                    {
                        GoodID        = goodChild.Good.GoodID,
                        Title         = goodChild.Good.Title,
                        SubTitle      = goodChild.Good.SubTitle,
                        RealPrice     = goodChild.Good.RealPrice,
                        GoodChildID   = goodChild.GoodChildID,
                        Specification = goodChild.Specification,
                        AddPrice      = goodChild.AddPrice,
                        Image         = goodChild.Image,
                        num           = num
                    });
                    if (string.IsNullOrEmpty(order.Image))
                    {
                        order.Image = goodChild.Image;
                    }
                    if (order.GoodID == 0)
                    {
                        order.GoodID = goodChild.Good.GoodID;
                    }
                    if (string.IsNullOrEmpty(order.Title))
                    {
                        order.Title = goodChild.Good.Title;
                    }
                    if (userID != null)
                    {
                        var t = entity.GoodCart.Where(o => o.UserID == userID && o.GoodChildID == goodChildID).FirstOrDefault();
                        if (t != null)
                        {
                            entity.GoodCart.Remove(t);
                        }
                    }
                }


                order.OrderID                = DateTime.Now.ToString("yyMMddhhmmssfff") + new Random().Next(100, 1000).ToString();
                order.UserID                 = userID;
                order.State                  = 1;
                order.Detail                 = JsonConvert.SerializeObject(orderDetailsModel);
                order.Remark1                = liuyan;
                order.CreateTime             = DateTime.Now;
                order.UpdateTime             = DateTime.Now;
                order.LogisticsAddress       = request["dizhi"];
                order.LogisticsTel           = request["Tel"];
                order.LogisticsPerson        = request["shouhuoren"];
                order.OrderExtend            = new OrderExtend();
                order.OrderExtend.TotalPrice = orderDetailsModel.OrderDetailModelList.Sum(o => (o.RealPrice + o.AddPrice) * o.num);


                order.OrderExtend.DiscountPrice     = 0;
                order.OrderExtend.LogisticsPrice    = 0;
                order.OrderExtend.PaymentPrice      = 0;
                order.OrderExtend.ThirdPartyPayment = payway;


                WholeFieldActivity wholeFieldActivity = entity.WholeFieldActivity.Where(o => o.Type == 0).FirstOrDefault();
                if (wholeFieldActivity != null)
                {
                    if (order.OrderExtend.TotalPrice >= wholeFieldActivity.FillPrice)
                    {
                        if (wholeFieldActivity.DiscountPrice != null)
                        {
                            order.OrderExtend.DiscountPrice = wholeFieldActivity.DiscountPrice.Value;
                        }
                    }
                }
                order.OrderExtend.PaymentPrice = order.OrderExtend.TotalPrice - order.OrderExtend.DiscountPrice;
                if (!baoyou)
                {
                    order.OrderExtend.LogisticsPrice = Convert.ToInt32(ConfigurationManager.AppSettings["LogisticsPrice"]);
                    wholeFieldActivity = entity.WholeFieldActivity.Where(o => o.Type == 1).FirstOrDefault();
                    if (wholeFieldActivity != null)
                    {
                        if (order.OrderExtend.PaymentPrice >= wholeFieldActivity.FillPrice)
                        {
                            order.OrderExtend.LogisticsPrice = 0;
                        }
                    }
                }

                order.OrderExtend.PaymentPrice = order.OrderExtend.TotalPrice - order.OrderExtend.DiscountPrice + order.OrderExtend.LogisticsPrice;
                //if (jifen == "true" && !string.IsNullOrEmpty(authentication.state))
                //{
                //    var user = entity.User.Find(authentication.userID);
                //    order.OrderExtend.UseIntegral = user.UserExtend.Integral;
                //    order.OrderExtend.PaymentPrice -= (order.OrderExtend.UseIntegral / 100);
                //}

                //order.OrderExtend.GainIntegral = Convert.ToInt32(order.OrderExtend.TotalPrice - order.OrderExtend.DiscountPrice + order.OrderExtend.LogisticsPrice);

                OrderLog orderLog = new OrderLog();
                orderLog.State      = order.State;
                orderLog.CreateTime = DateTime.Now;
                orderLog.UserId     = order.UserID;
                orderLog.Mark       = "用户下单";
                order.OrderLog.Add(orderLog);
                entity.Order.Add(order);

                entity.SaveChanges();
            }
            string subject = "分享";
            string body    = "";

            foreach (var v in orderDetailsModel.OrderDetailModelList)
            {
                body += v.Title + " ";
            }
            body = body.Trim();

            createOrder.orderid = order.OrderID;
            createOrder.subject = subject;
            createOrder.body    = body;
            createOrder.fee     = order.OrderExtend.PaymentPrice.ToString("#0.00");
            return(createOrder);
        }
 public RealizeOrderPropositionResponse(Order order)
 {
     Order  = order;
     Result = RealizeOrderPropositionResult.Success;
 }
 private static int ClientMethod(Order order)
 => order.OrderID;
        public int CreateOrder(Order order)
        {
            Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
            // These commented lines cause EF Core to do wierd things.
            // Instead, make the query manually.

            // order = _context.Orders.Add(order).Entity;
            // _context.SaveChanges();
            // return order.OrderId;

            string shippedDate = order.ShippedDate.HasValue ? "'" + string.Format("yyyy-MM-dd", order.ShippedDate.Value) + "'" : "NULL";
            var    sql         = "INSERT INTO Orders (" +
                                 "CustomerId, EmployeeId, OrderDate, RequiredDate, ShippedDate, ShipVia, Freight, ShipName, ShipAddress, " +
                                 "ShipCity, ShipRegion, ShipPostalCode, ShipCountry" +
                                 ") VALUES (" +
                                 $"'{order.CustomerId}','{order.EmployeeId}','{order.OrderDate:yyyy-MM-dd}','{order.RequiredDate:yyyy-MM-dd}'," +
                                 $"{shippedDate},'{order.ShipVia}','{order.Freight}','{order.ShipName}','{order.ShipAddress}'," +
                                 $"'{order.ShipCity}','{order.ShipRegion}','{order.ShipPostalCode}','{order.ShipCountry}')";

            sql += ";\nSELECT OrderID FROM Orders ORDER BY OrderID DESC LIMIT 1;";

            using (var command = _context.Database.GetDbConnection().CreateCommand())
            {
                command.CommandText = sql;
                _context.Database.OpenConnection();

                using var dataReader = command.ExecuteReader();
                dataReader.Read();
                order.OrderId = Convert.ToInt32(dataReader[0]);
            }

            sql = ";\nINSERT INTO OrderDetails (" +
                  "OrderId, ProductId, UnitPrice, Quantity, Discount" +
                  ") VALUES ";
            foreach (var(orderDetails, i) in order.OrderDetails.WithIndex())
            {
                orderDetails.OrderId = order.OrderId;
                sql += (i > 0 ? "," : "") +
                       $"('{orderDetails.OrderId}','{orderDetails.ProductId}','{orderDetails.UnitPrice}','{orderDetails.Quantity}'," +
                       $"'{orderDetails.Discount}')";
            }

            if (order.Shipment != null)
            {
                var shipment = order.Shipment;
                shipment.OrderId = order.OrderId;
                sql += ";\nINSERT INTO Shipments (" +
                       "OrderId, ShipperId, ShipmentDate, TrackingNumber" +
                       ") VALUES (" +
                       $"'{shipment.OrderId}','{shipment.ShipperId}','{shipment.ShipmentDate:yyyy-MM-dd}','{shipment.TrackingNumber}')";
            }

            using (var command = _context.Database.GetDbConnection().CreateCommand())
            {
                command.CommandText = sql;
                _context.Database.OpenConnection();
                command.ExecuteNonQuery();
            }

            return(order.OrderId);
        }
            protected override void Seed(DbContext context)
            {
                context.Database.EnsureCreatedResiliently();

                var order11 = new Order
                {
                    Name      = "Order11",
                    ItemCount = 4,
                    OrderDate = new DateTime(2000, 1, 20)
                };
                var order12 = new Order
                {
                    Name      = "Order12",
                    ItemCount = 8,
                    OrderDate = new DateTime(2000, 2, 21)
                };
                var order13 = new Order
                {
                    Name      = "Order13",
                    ItemCount = 15,
                    OrderDate = new DateTime(2000, 3, 20)
                };
                var order21 = new Order
                {
                    Name      = "Order21",
                    ItemCount = 16,
                    OrderDate = new DateTime(2000, 4, 21)
                };
                var order22 = new Order
                {
                    Name      = "Order22",
                    ItemCount = 23,
                    OrderDate = new DateTime(2000, 5, 20)
                };
                var order31 = new Order
                {
                    Name      = "Order31",
                    ItemCount = 42,
                    OrderDate = new DateTime(2000, 6, 21)
                };

                var customer1 = new Customer
                {
                    FirstName = "Customer",
                    LastName  = "One",
                    Orders    = new List <Order>
                    {
                        order11,
                        order12,
                        order13
                    }
                };
                var customer2 = new Customer
                {
                    FirstName = "Customer",
                    LastName  = "Two",
                    Orders    = new List <Order>
                    {
                        order21,
                        order22
                    }
                };
                var customer3 = new Customer
                {
                    FirstName = "Customer",
                    LastName  = "Three",
                    Orders    = new List <Order>
                    {
                        order31
                    }
                };

                ((UDFSqlContext)context).Customers.AddRange(customer1, customer2, customer3);
                ((UDFSqlContext)context).Orders.AddRange(order11, order12, order13, order21, order22, order31);
            }
示例#41
0
 public void Update(Order item)
 {
     _teaMarketContext.Entry(item).State = EntityState.Modified;
 }
示例#42
0
        public void ComplexEntityTest()
        {
            IRepository <Customer> _customerRepo = new MongoRepository <Customer>();
            IRepository <Product>  _productRepo  = new MongoRepository <Product>();

            var customer = new Customer();

            customer.FirstName   = "Erik";
            customer.LastName    = "Swaun";
            customer.Phone       = "123 99 8767";
            customer.Email       = "*****@*****.**";
            customer.HomeAddress = new Address
            {
                Address1 = "Main bulevard",
                Address2 = "1 west way",
                PostCode = "89560",
                City     = "Tempare",
                Country  = "Arizona"
            };

            var order = new Order();

            order.PurchaseDate = DateTime.Now.AddDays(-2);
            var orderItems = new List <OrderItem>();

            var shampoo = _productRepo.Add(new Product()
            {
                Name = "Palmolive Shampoo", Price = 5
            });
            var paste = _productRepo.Add(new Product()
            {
                Name = "Mcleans Paste", Price = 4
            });


            var item1 = new OrderItem {
                Product = shampoo, Quantity = 1
            };
            var item2 = new OrderItem {
                Product = paste, Quantity = 2
            };

            orderItems.Add(item1);
            orderItems.Add(item2);

            order.Items = orderItems;

            customer.Orders = new List <Order>
            {
                order
            };

            _customerRepo.Add(customer);

            Assert.IsNotNull(customer.Id);
            Assert.IsNotNull(customer.Orders[0].Items[0].Product.Id);

            // get the orders
            var theOrders     = _customerRepo.Where(c => c.Id == customer.Id).Select(c => c.Orders).ToList();
            var theOrderItems = theOrders[0].Select(o => o.Items);

            Assert.IsNotNull(theOrders);
            Assert.IsNotNull(theOrderItems);
        }
示例#43
0
        public IResult Update(Order order)
        {
            _carOrderDal.Update(order);

            return(new SuccessResult(Messages.OrderUpdated));
        }
示例#44
0
 void Start()
 {
     rb = GetComponent<Rigidbody>();
     plated = new Order(); //Items on plate, to be compared at ServingCounter
     itemSprites = new Image[4];
 }
示例#45
0
        public IResult Add(Order order)
        {
            _carOrderDal.Add(order);

            return(new SuccessResult(Messages.OrderAdded));
        }
示例#46
0
 public Guid Create(Order order)
 {
     _teaMarketContext.Orders.Add(order);
     _teaMarketContext.SaveChanges();
     return order.Id;
 }
示例#47
0
        public ActionResult SendCart(Order ord, string submit)
        {
            List <Product> completedProduct;
            Order          order;


            TimeSpan noon = new TimeSpan(24, 0, 0);

            //int hourdiff = span.Hours;
            if (ord.deliveryDate == null)
            {
                ModelState.AddModelError("deliveryDate", "Please specify delivery date.");
                return(Cart());
            }

            bool isNew = true;

            if (ord != null)
            {
                order = db.Order.FirstOrDefault(x => x.orderID == ord.orderID);;
                isNew = false;

                if (order == null)
                {
                    order = new Order();
                    isNew = true;
                }
            }
            else
            {
                order = new Order();
            }

            completedProduct = (List <Product>)Session["cart"];
            Member profile = null;
            Member user    = null;

            DateTime dnow    = DateTime.Now.Date;
            TimeSpan span    = (TimeSpan)(ord.deliveryDate - dnow);
            int      daydiff = span.Days;

            switch (submit)
            {
            case "Submit":


                if (daydiff <= 0)
                {
                    ModelState.AddModelError("", "Invalid Code verified.");
                    return(View());
                }
                if (DateTime.Now.TimeOfDay >= noon)
                {
                    ModelState.AddModelError("", "Invalid 2 Code verified.");
                    return(View());
                }

                if (Session["cart"] != null && completedProduct.Count > 0)
                {
                    List <int> detailIds = order.OderDetail.Select(x => x.detailID).ToList();
                    foreach (int id in detailIds)
                    {
                        var detail = db.OderDetail.FirstOrDefault(x => x.detailID == id);

                        order.OderDetail.Remove(detail);
                        db.OderDetail.Remove(detail);
                    }

                    if (!isNew)
                    {
                        db.SaveChanges();
                    }

                    order.OderDetail  = new List <OderDetail>();
                    profile           = db.Member.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
                    order.Member      = profile;
                    order.orderStatus = 1;     // save
                    foreach (Product product in completedProduct)
                    {
                        if (product.quantity > 0)
                        {
                            OderDetail orderDetail = new OderDetail();
                            orderDetail.productID       = product.productID;
                            orderDetail.orderID         = order.orderID;
                            orderDetail.productQuantity = product.quantity;
                            order.OderDetail.Add(orderDetail);
                        }
                    }
                    order.orderDate    = DateTime.Now;
                    order.deliveryDate = ord.deliveryDate;
                    order.feedBack     = ord.feedBack;

                    if (isNew)
                    {
                        db.Order.Add(order);
                    }
                    db.SaveChanges();
                }
                else
                {
                    return(View("Cart", "Home"));
                }

                Session.Remove("cart");
                user = db.Member.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
                return(View("History", user.Order));


            case "Save":
                if (Session["cart"] != null && completedProduct.Count > 0)
                {
                    //order.OderDetail.Clear();
                    List <int> detailIds = order.OderDetail.Select(x => x.detailID).ToList();
                    foreach (int id in detailIds)
                    {
                        var detail = db.OderDetail.FirstOrDefault(x => x.detailID == id);

                        order.OderDetail.Remove(detail);
                        db.OderDetail.Remove(detail);
                    }

                    if (!isNew)
                    {
                        db.SaveChanges();
                    }
                    //order.OderDetail.Clear();
                    //if (!isNew)
                    //        db.SaveChanges();
                    //order.OderDetail = new List<OderDetail>();
                    profile           = db.Member.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
                    order.Member      = profile;
                    order.orderStatus = 2;     // Draft
                    foreach (Product product in completedProduct)
                    {
                        if (product.quantity > 0)
                        {
                            OderDetail orderDetail = new OderDetail();
                            orderDetail.productID = product.productID;
                            orderDetail.orderID   = order.orderID;

                            orderDetail.productQuantity = product.quantity;
                            order.OderDetail.Add(orderDetail);
                        }
                    }
                    order.orderDate    = DateTime.Now;
                    order.deliveryDate = ord.deliveryDate;
                    order.feedBack     = ord.feedBack;

                    if (isNew)
                    {
                        db.Order.Add(order);
                    }

                    db.SaveChanges();
                }
                else
                {
                    return(View("Product", "Home"));
                }

                Session.Remove("cart");
                user = db.Member.FirstOrDefault(x => x.UserName == this.User.Identity.Name);
                return(View("History", user.Order));

            default:
                return(null);
            }
        }
示例#48
0
        public IResult Delete(Order order)
        {
            _carOrderDal.Delete(order);

            return(new SuccessResult(Messages.OrderDeleted));
        }
示例#49
0
 public async Task UpdateAsync(Order order)
 {
     _context.Orders.Update(order);
     await _context.SaveChangesAsync();
 }
示例#50
0
        public ActionResult Cart(int id = 0, int orderId = 0)
        {
            List <Product> completedProduct;
            Order          order = null;

            if (orderId != 0)
            {
                order = db.Order.FirstOrDefault(x => x.orderID == orderId);
            }

            if (order != null && order.orderStatus.Value != 2)
            {
                return(RedirectToAction("Details", "Home", new { id = order.orderID }));
            }

            Session["currentOrderId"] = 0;

            if (Session["cart"] == null)
            {
                completedProduct = new List <Product>();

                if (order != null)
                {
                    Session["currentOrderId"] = orderId;
                    List <Product> products = new List <Product>();
                    foreach (OderDetail detail in order.OderDetail)
                    {
                        detail.Product.quantity = detail.productQuantity;
                        products.Add(detail.Product);
                    }
                    Session["cart"]  = products;
                    completedProduct = (List <Product>)Session["cart"];
                }
            }
            else
            {
                completedProduct = (List <Product>)Session["cart"];
            }



            Product tproduct = db.Product.Find(id);

            if (tproduct != null)
            {
                Product orderedItem = completedProduct.FirstOrDefault(x => x.productID == id);
                if (orderedItem != null)
                {
                    orderedItem.quantity += 1;
                }
                else
                {
                    tproduct.quantity = 1;
                    completedProduct.Add(tproduct);
                }
            }

            if (Session != null)
            {
                Session["cart"] = completedProduct;
            }



            if (order != null)
            {
                return(View("Cart", order));
            }
            else
            {
                return(View("Cart"));
            }
        }
示例#51
0
        public async Task <ActionResult> OrderHistoryDetail(int id)
        {
            Order orders = await _order.GetByIdAsync(id);

            return(View(orders));
        }
示例#52
0
 public async Task DeleteAsync(Order order)
 {
     _context.Remove(order);
     await _context.SaveChangesAsync();
 }
        public Order GetOrder(Guid orderID)
        {
            SimpleProductRepository  productRepository  = new SimpleProductRepository();
            SimpleCustomerRepository customerRepository = new SimpleCustomerRepository();
            Order result = null;

            var batch = new BatchSql();

            batch.Append(OrdersTable.Select().Where("OrderID", orderID));

            //items

            //products for the items
            var sql = new SqlStatement(connectionStringName);

            sql.Add("SELECT ");
            sql.Add(ProductsTable.COLUMN_LIST);
            sql.Add(OrderItemsTable.COLUMN_LIST);
            sql.Add("FROM Products INNER JOIN OrderItems ON Products.SKU = OrderItems.SKU");
            sql.Add("WHERE SKU IN (SELECT SKU FROM OrderItems WHERE OrderID=@OrderID)");

            //transactions
            batch.Append(TransactionsTable.Select().Where("orderid", orderID));

            int shippingAddressID = 0;
            int billingAddressID  = 0;
            int shippingMethodID  = 0;

            //pull it
            var cmd = sql.BuildCommand();

            using (var rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection)) {
                if (rdr.Read())
                {
                    result = new Order(OrdersTable.ReadOrderStatusID(rdr))
                    {
                        DateCreated       = OrdersTable.ReadCreatedOn(rdr),
                        DateShipped       = OrdersTable.ReadDateShipped(rdr),
                        UserName          = OrdersTable.ReadUserName(rdr),
                        DiscountAmount    = OrdersTable.ReadDiscountAmount(rdr),
                        DiscountReason    = OrdersTable.ReadDiscountReason(rdr),
                        EstimatedDelivery = OrdersTable.ReadEstimatedDelivery(rdr),
                        ID              = orderID,
                        OrderNumber     = OrdersTable.ReadOrderNumber(rdr),
                        ShippingAmount  = OrdersTable.ReadShippingAmount(rdr),
                        ShippingService = OrdersTable.ReadShippingService(rdr),
                        TaxAmount       = OrdersTable.ReadTaxAmount(rdr),
                    };

                    billingAddressID  = OrdersTable.ReadBillingAddressID(rdr);
                    shippingAddressID = OrdersTable.ReadShippingAddressID(rdr);
                }

                //load the items
                result.Items = new List <OrderLine>();
                if (rdr.NextResult())
                {
                    while (rdr.Read())
                    {
                        var product = productRepository.LoadProduct(rdr);
                        var item    = new OrderLine(OrderItemsTable.ReadDateAdded(rdr), OrderItemsTable.ReadQuantity(rdr), product);
                        result.Items.Add(item);
                    }
                }

                //transactions
                result.Transactions = new List <Transaction>();
                if (rdr.NextResult())
                {
                    while (rdr.Read())
                    {
                        Transaction t = new Transaction(
                            TransactionsTable.ReadTransactionID(rdr),
                            orderID,
                            TransactionsTable.ReadAmount(rdr),
                            TransactionsTable.ReadTransactionDate(rdr),
                            TransactionsTable.ReadAuthorizationCode(rdr),
                            TransactionsTable.ReadNotes(rdr),
                            TransactionsTable.ReadProcessor(rdr));

                        result.Transactions.Add(t);
                    }
                }
            }
            sql = new SqlStatement(connectionStringName);

            //addresses
            batch.Append(AddressesTable.Select().Where("addressid", shippingAddressID));

            batch.Append(AddressesTable.Select().Where("addressid", billingAddressID));

            //shipping method
            batch.Append(ShippingMethodsTable.Select().Where("shippingmethodid", shippingMethodID));

            cmd = batch.BuildCommand(connectionStringName);


            using (var rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection)) {
                //shipping address
                if (rdr.Read())
                {
                    //shipping
                    result.ShippingAddress = customerRepository.LoadAddress(rdr);
                }
                //billing address
                if (rdr.NextResult())
                {
                    if (rdr.Read())
                    {
                        result.BillingAddress = customerRepository.LoadAddress(rdr);
                    }
                }
                //shipping method
                if (rdr.NextResult())
                {
                    if (rdr.Read())
                    {
                        LoadShipping(rdr);
                    }
                }
            }

            return(result);
        }
示例#54
0
 public async Task CreateAsync(Order order)
 {
     _context.Add(order);
     await _context.SaveChangesAsync();
 }
示例#55
0
 public void UpdateOrder(Order updatedOrder)
 {
     orderContext.Update(updatedOrder);
     orderContext.Commit();
 }           //after the new methods we have to update the interface at the core/contracts/ IOrderService
 public void Save(Order order, Transaction transaction)
 {
     throw new NotImplementedException();
 }
示例#57
0
        /// <summary>
        /// the method in which the thread monitors the execution of orders /
        /// метод, в котором работает поток следящий за исполнением заявок
        /// </summary>
        private void CheckPositions()
        {
            if (MainWindow.ProccesIsWorked == false)
            {
                return;
            }

            if (ServerTime == DateTime.MinValue)
            {
                return;
            }

            if (_startProgram != StartProgram.IsOsTrader)
            {
                return;
            }

            try
            {
                List <Position> openDeals = _botTab.PositionsOpenAll;

                if (openDeals == null)
                {
                    return;
                }

                for (int i = 0; i < openDeals.Count; i++)
                {
                    Position position = openDeals[i];

                    for (int i2 = 0; position.OpenOrders != null && i2 < position.OpenOrders.Count; i2++)
                    {
                        // open orders / ОТКРЫВАЮЩИЕ ОРДЕРА
                        Order openOrder = position.OpenOrders[i2];

                        if (openOrder.State != OrderStateType.Activ &&
                            openOrder.State != OrderStateType.Patrial)
                        {
                            continue;
                        }

                        if (IsInArray(openOrder))
                        {
                            continue;
                        }

                        if (SecondToOpenIsOn &&
                            openOrder.TimeCreate.Add(openOrder.LifeTime) < ServerTime)
                        {
                            SendNewLogMessage(OsLocalization.Trader.Label70 + openOrder.NumberMarket,
                                              LogMessageType.Trade);
                            SendOrderToClose(openOrder, openDeals[i]);
                        }

                        if (SetbackToOpenIsOn &&
                            openOrder.Side == Side.Buy)
                        {
                            decimal maxSpread = GetMaxSpread(openOrder);

                            if (Math.Abs(_botTab.PriceBestBid - openOrder.Price) > maxSpread)
                            {
                                SendNewLogMessage(OsLocalization.Trader.Label157 + openOrder.NumberMarket,
                                                  LogMessageType.Trade);
                                SendOrderToClose(openOrder, openDeals[i]);
                            }
                        }

                        if (SetbackToOpenIsOn &&
                            openOrder.Side == Side.Sell)
                        {
                            decimal maxSpread = GetMaxSpread(openOrder);

                            if (Math.Abs(openOrder.Price - _botTab.PriceBestAsk) > maxSpread)
                            {
                                SendNewLogMessage(OsLocalization.Trader.Label157 + openOrder.NumberMarket,
                                                  LogMessageType.Trade);
                                SendOrderToClose(openOrder, openDeals[i]);
                            }
                        }
                    }


                    for (int i2 = 0; position.CloseOrders != null && i2 < position.CloseOrders.Count; i2++)
                    {
                        // close orders / ЗАКРЫВАЮЩИЕ ОРДЕРА
                        Order closeOrder = position.CloseOrders[i2];

                        if ((closeOrder.State != OrderStateType.Activ &&
                             closeOrder.State != OrderStateType.Patrial))
                        {
                            continue;
                        }

                        if (IsInArray(closeOrder))
                        {
                            continue;
                        }

                        if (SecondToCloseIsOn &&
                            closeOrder.TimeCreate.Add(closeOrder.LifeTime) < ServerTime)
                        {
                            SendNewLogMessage(OsLocalization.Trader.Label70 + closeOrder.NumberMarket,
                                              LogMessageType.Trade);
                            SendOrderToClose(closeOrder, openDeals[i]);
                        }

                        if (SetbackToCloseIsOn &&
                            closeOrder.Side == Side.Buy)
                        {
                            decimal priceRedLine = closeOrder.Price -
                                                   _botTab.Securiti.PriceStep * SetbackToClosePosition;

                            if (_botTab.PriceBestBid <= priceRedLine)
                            {
                                SendNewLogMessage(OsLocalization.Trader.Label157 + closeOrder.NumberMarket,
                                                  LogMessageType.Trade);
                                SendOrderToClose(closeOrder, openDeals[i]);
                            }
                        }

                        if (SetbackToCloseIsOn &&
                            closeOrder.Side == Side.Sell)
                        {
                            decimal priceRedLine = closeOrder.Price +
                                                   _botTab.Securiti.PriceStep * SetbackToClosePosition;

                            if (_botTab.PriceBestAsk >= priceRedLine)
                            {
                                SendNewLogMessage(OsLocalization.Trader.Label157 + closeOrder.NumberMarket,
                                                  LogMessageType.Trade);
                                SendOrderToClose(closeOrder, openDeals[i]);
                            }
                        }
                    }
                }
            }
            catch
            (Exception error)
            {
                SendNewLogMessage(error.ToString(), LogMessageType.Error);
            }
        }
        /// <summary>
        /// Started the transaction explicitly. We have options to commit / roll-back transactions.
        /// </summary>
        private static int TestOnExplicitlyStartedTransaction()
        {
            var affectedRows = 0;
            var customerId   = "VINET";
            var employeeId   = 5;

            var invalidEmployeeId = int.MaxValue;

            using (var dbContext = new NorthwindEntities())
            {
                using (var transaction = dbContext.Database.BeginTransaction())
                {
                    try
                    {
                        #region [Add Orders]

                        // This cause an error
                        var firstOrder = new Order()
                        {
                            CustomerID = customerId,
                            EmployeeID = invalidEmployeeId // employeeId
                        };

                        dbContext.Orders.Add(firstOrder);

                        var secondOrder = new Order()
                        {
                            CustomerID = customerId,
                            EmployeeID = employeeId
                        };

                        secondOrder.Order_Details.Add(new Order_Detail()
                        {
                            OrderID   = secondOrder.OrderID,
                            ProductID = 5,
                            UnitPrice = 12.34m,
                            Quantity  = 100,
                            Discount  = 0.2f
                        });

                        dbContext.Orders.Add(secondOrder);

                        #endregion

                        affectedRows = dbContext.SaveChanges();

                        // Finish successfully => Commit transaction
                        transaction.Commit();

                        // Test to Rollback() insted of Commit() and you will see that the changes are rolled-back
                        //transaction.Rollback();

                        Console.WriteLine("- Finish successfully => Commit transaction");
                    }
                    catch (Exception)
                    {
                        // Finish Unsuccessfully => Rollback transaction
                        transaction.Rollback();

                        Console.WriteLine("- Exception: Finish Unsuccessfully => Rollback transaction");
                    }
                }
            }

            return(affectedRows);
        }
 public Model()
 {
     _products = DataBaseManager.GetProductsFromProductTable();
     _order    = new Order();
 }
示例#60
0
 public OrderConfirmationIntegrationEvent(Order orderinfo)
 {
     _orderinfo = orderinfo;
 }