Trading and Orders

// Set a Limit Order to be good until market close
DefaultOrderProperties.TimeInForce = TimeInForce.Day;
LimitOrder("IBM", 100, 120);

// Set a Limit Order to be good until noon
LimitOrder("IBM", 100, 120, orderProperties: new OrderProperties 
{
    TimeInForce = TimeInForce.GoodTilDate(new DateTime(2019, 6, 19, 12, 0, 0))
});

# Set a Limit Order to be good until market close
self.default_order_properties.time_in_force = TimeInForce.DAY
self.limit_order("IBM", 100, 120)

# Set a Limit Order to be good until noon
order_properties = OrderProperties()
order_properties.time_in_force = TimeInForce.good_til_date(datetime(2019, 6, 19, 12, 0, 0))
self.limit_order("IBM", 100, 120, order_properties=order_properties)

// Tag an order on creation
var ticket = LimitOrder("SPY", 100, 221.05, tag: "Original tag");

// Update the tag with UpdateTag
ticket.UpdateTag("Updated tag");

// Update the tag with UpdateOrderFields
ticket.Update(new() { Tag = "Another tag" });

 # Tag an order on creation
ticket = self.limit_order("SPY", 100, 221.05, "Original tag")

# Update the tag with UpdateTag
ticket.update_tag("Updated tag")

# Update the tag with UpdateOrderFields
update_settings = UpdateOrderFields()
update_settings.tag = "Another tag"
ticket.update(update_settings)

public class OrderPropertiesAlgorithm : QCAlgorithm
{
    private Symbol _spy;
    private decimal _lastPrice = 0m;

    public override void Initialize()
    {
        SetStartDate(2022, 1, 1);
        SetEndDate(2022, 2, 1);
        
        // Add extended market hour SPY data for trading.
        _spy = AddEquity("SPY", extendedMarketHours: true).Symbol;

        // Add a Scheduled Event to trade 2 hours enter a position during pre-market.
        Schedule.On(DateRules.EveryDay(_spy), TimeRules.BeforeMarketOpen(_spy, 120), OpenPosition);
        // Add a Scheduled Event to exit the position 15 minutes after market open.
        Schedule.On(DateRules.EveryDay(_spy), TimeRules.AfterMarketOpen(_spy, 15), () => Liquidate());
        // Add a Scheduled Event to cache the daily close price so you can generate signals the next day.
        Schedule.On(DateRules.EveryDay(_spy), TimeRules.BeforeMarketClose(_spy), GetLastPrice);
        // Add a warm-up period so the algorithm trades on the first day in live mode.
        SetWarmUp(TimeSpan.FromDays(1));
    }

    private void OpenPosition()
    {
        if (_lastPrice > 0m)
        {
            var currentPrice = Securities[_spy].Price;

            // Define the order properties to trade in pre-market. The order will only valid for 3 minutes to avoid 
            // stale fills.
            var orderProperties = new InteractiveBrokersOrderProperties
            {
                TimeInForce = TimeInForce.GoodTilDate(Time.AddMinutes(3)),
                OutsideRegularTradingHours = true
            };

            // Buy if the overnight direction is upward, indicating positive market sentiment.
            // Sell if the overnight direction is downward, indicating negative market sentiment.
            // Note that pre-market orders do not accept market order.
            LimitOrder(_spy, currentPrice > _lastPrice ? 10 : -10, currentPrice, orderProperties: orderProperties);
        }
    }

    private void GetLastPrice()
    {
        _lastPrice = Securities[_spy].Price;
    }
}

class OrderPropertiesAlgorithm(QCAlgorithm):
    _last_price = None

    def initialize(self) -> None:
        self.set_start_date(2022, 1, 1)
        self.set_end_date(2022, 2, 1)

        # Add extended market hour SPY data for trading.
        self._spy = self.add_equity("SPY", extended_market_hours=True).symbol

        # Add a Scheduled Event to trade 2 hours enter a position during pre-market.
        self.schedule.on(
            self.date_rules.every_day(self._spy),
            self.time_rules.before_market_open(self._spy, 120),
            self._open_position
        )
        # Add a Scheduled Event to exit the position 15 minutes after market open.
        self.schedule.on(
            self.date_rules.every_day(self._spy),
            self.time_rules.after_market_open(self._spy, 15),
            self.liquidate
        )
        # Add a Scheduled Event to cache the daily close price so you can generate signals the next day.
        self.schedule.on(
            self.date_rules.every_day(self._spy),
            self.time_rules.before_market_close(self._spy),
            self._get_last_price
        )
        # Add a warm-up period so the algorithm trades on the first day in live mode.
        self.set_warm_up(timedelta(1))
    
    def _open_position(self) -> None:
        if self._last_price:
            current_price = self.securities[self._spy].price

            # Define the order properties to trade in pre-market. The order will only valid for 3 minutes to avoid 
            # stale fills.
            order_properties = OrderProperties()
            order_properties.time_in_force = TimeInForce.good_til_date(self.time + timedelta(minutes=3))
            order_properties.outside_regular_trading_hours = True

            # Buy if the overnight direction is upward, indicating positive market sentiment.
            # Sell if the overnight direction is downward, indicating negative market sentiment.
            # Note that pre-market orders do not accept market order.
            quantity = 10 if current_price > self._last_price else -10
            self.limit_order(self._spy, quantity, current_price, order_properties=order_properties)    

    def _get_last_price(self) -> None:
        self._last_price = self.securities[self._spy].price