experimental.py

import os
import sys
import six
import pause
import requests
import argparse
import logging.config
from selenium import webdriver
from dateutil import parser as date_parser
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC

"""

This is an experimental script which attempts at utilizing some Nike APIs.

Current implementation:
    1. Login with Selenium
    2. Using the driver's stored cookies, make a Nike API request to add the desired item to your cart
    3. Load the checkout page and place an order
    
Not sure if this will be any faster than the other script...

"""


logging.config.dictConfig({
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "default": {
            "format": "%(asctime)s [PID %(process)d] [Thread %(thread)d] [%(levelname)s] [%(name)s] %(message)s"
        }
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "level": "INFO",
            "formatter": "default",
            "stream": "ext://sys.stdout"
        }
    },
    "root": {
        "level": "INFO",
        "handlers": [
            "console"
        ]
    }
})

NIKE_HOME_URL = "https://www.nike.com/us/en_us/"
NIKE_CHECKOUT_URL = "https://www.nike.com/checkout"
NIKE_CART_API_URL = "https://secure-store.nike.com/us/services/jcartService"
LOGGER = logging.getLogger()


def run(driver, username, password, product_id, sku_id, shoe_size, login_time=None, release_time=None,
        page_load_timeout=None, screenshot_path=None, purchase=False, num_retries=None):
    driver.maximize_window()
    driver.set_page_load_timeout(page_load_timeout)

    if login_time:
        LOGGER.info("Waiting until login time: " + login_time)
        pause.until(date_parser.parse(login_time))

    try:
        login(driver=driver, username=username, password=password)
    except Exception as e:
        LOGGER.exception("Failed to login: " + str(e))
        six.reraise(Exception, e, sys.exc_info()[2])

    if release_time:
        LOGGER.info("Waiting until release time: " + release_time)
        pause.until(date_parser.parse(release_time))

    num_retries_attempted = 0
    while True:
        try:
            try:
                LOGGER.info("Adding item to cart")
                add_item_to_cart(driver=driver, product_id=product_id, sku_id=sku_id, size=shoe_size)
            except Exception as e:
                LOGGER.exception("Failed to add item to cart " + str(e))
                six.reraise(Exception, e, sys.exc_info()[2])

            try:
                LOGGER.info("Requesting page: " + NIKE_CHECKOUT_URL)
                driver.get(NIKE_CHECKOUT_URL)
            except TimeoutException:
                LOGGER.info("Page load timed out but continuing anyway")

            if purchase:
                try:
                    click_place_order_button(driver=driver)
                except Exception as e:
                    LOGGER.exception("Failed to click place order button: " + str(e))
                    six.reraise(Exception, e, sys.exc_info()[2])

            LOGGER.info("Purchased shoe")
            break
        except Exception:
            if num_retries and num_retries_attempted < num_retries:
                num_retries_attempted += 1
                continue
            else:
                break

    if screenshot_path:
        LOGGER.info("Saving screenshot")
        driver.save_screenshot(screenshot_path)

    driver.quit()


def login(driver, username, password):
    try:
        LOGGER.info("Requesting page: " + NIKE_HOME_URL)
        driver.get(NIKE_HOME_URL)
    except TimeoutException:
        LOGGER.info("Page load timed out but continuing anyway")

    LOGGER.info("Waiting for login button to become clickable")
    wait_until_clickable(driver=driver, xpath="//li[@js-hook='exp-join-login']/button")

    LOGGER.info("Clicking login button")
    driver.find_element_by_xpath("//li[@js-hook='exp-join-login']/button").click()

    LOGGER.info("Waiting for login fields to become visible")
    wait_until_visible(driver=driver, xpath="//input[@name='emailAddress']")

    LOGGER.info("Entering username and password")
    email_input = driver.find_element_by_xpath("//input[@name='emailAddress']")
    email_input.clear()
    email_input.send_keys(username)
    password_input = driver.find_element_by_xpath("//input[@name='password']")
    password_input.clear()
    password_input.send_keys(password)

    LOGGER.info("Logging in")
    driver.find_element_by_xpath("//input[@value='LOG IN']").click()
    wait_until_visible(driver=driver, xpath="//span[text()='My Account']")

    LOGGER.info("Successfully logged in")


def click_place_order_button(driver):
    xpath = "//button[text()='Place Order']"

    LOGGER.info("Waiting for place order button to become clickable")
    wait_until_clickable(driver, xpath=xpath, duration=10)

    LOGGER.info("Clicking place order button")
    driver.find_element_by_xpath(xpath).click()


def add_item_to_cart(driver, product_id, sku_id, size):
    cookies = driver.get_cookies()
    params = {
        "action": "addItem",
        "lang_locale": "en_US",
        "catalogId": "1",
        "productId": product_id,
        "qty": "1",
        "price": "",
        "skuAndSize": "{}:{}".format(sku_id, size),
        "rt": "json",
        "view": "3",
        "skuId": sku_id,
        "displaySize": "10"
    }
    headers = {
        "user-agent": "Mozilla/5.0 (X11; Linux x86_64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36",
        "origin": "https://www.nike.com",
        "accept-encoding": "gzip, deflate, br",
        "accept-language": "en-US,en;q=0.9",
        "accept": "*/*",
        "scheme": "https"
    }
    response = requests.get(url=NIKE_CART_API_URL,
                            params=params, headers=headers, cookies=cookies)
    if response.status_code != 200:
        raise Exception("Request to add item to cart failed (code {}): {}".format(
            response.status_code, response.text))


def wait_until_clickable(driver, xpath=None, class_name=None, duration=10000, frequency=0.01):
    if xpath:
        WebDriverWait(driver, duration, frequency).until(EC.element_to_be_clickable((By.XPATH, xpath)))
    elif class_name:
        WebDriverWait(driver, duration, frequency).until(EC.element_to_be_clickable((By.CLASS_NAME, class_name)))


def wait_until_visible(driver, xpath=None, class_name=None, duration=10000, frequency=0.01):
    if xpath:
        WebDriverWait(driver, duration, frequency).until(EC.visibility_of_element_located((By.XPATH, xpath)))
    elif class_name:
        WebDriverWait(driver, duration, frequency).until(EC.visibility_of_element_located((By.CLASS_NAME, class_name)))


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--username", required=True)
    parser.add_argument("--password", required=True)
    parser.add_argument("--product-id", required=True)
    parser.add_argument("--sku-id", required=True)
    parser.add_argument("--shoe-size", required=True)
    parser.add_argument("--login-time", default=None)
    parser.add_argument("--release-time", default=None)
    parser.add_argument("--screenshot-path", default=None)
    parser.add_argument("--page-load-timeout", type=int, default=2)
    parser.add_argument("--driver-type", default="firefox", choices=("firefox", "chrome"))
    parser.add_argument("--headless", action="store_true")
    parser.add_argument("--purchase", action="store_true")
    parser.add_argument("--num-retries", type=int, default=1)
    args = parser.parse_args()

    driver = None
    if args.driver_type == "firefox":
        options = webdriver.FirefoxOptions()
        if args.headless:
            options.add_argument("--headless")
        executable_path = None
        if sys.platform == "darwin":
            executable_path = "./bin/geckodriver_mac"
        elif "linux" in sys.platform:
            executable_path = "./bin/geckodriver_linux"
        driver = webdriver.Firefox(executable_path=executable_path, firefox_options=options, log_path=os.devnull)
    elif args.driver_type == "chrome":
        options = webdriver.ChromeOptions()
        if args.headless:
            options.add_argument("headless")
        executable_path = None
        if sys.platform == "darwin":
            executable_path = "./bin/chromedriver_mac"
        elif "linux" in sys.platform:
            executable_path = "./bin/chromedriver_linux"
        driver = webdriver.Chrome(executable_path=executable_path, chrome_options=options)

    run(driver=driver, username=args.username, password=args.password, product_id=args.product_id,
        sku_id=args.sku_id, shoe_size=args.shoe_size, login_time=args.login_time, release_time=args.release_time,
        page_load_timeout=args.page_load_timeout, screenshot_path=args.screenshot_path,
        purchase=args.purchase, num_retries=args.num_retries)