def insert_price_data(card, printing, price, date, is_paper, db_cursor, logger, prod_mode):
"""Inserts the given instance of price data into the database of the associated cursor. An instance of price data is
the price for the printing of a card on a given date.
:param card: name of card
:param printing: set card was printed in
:param price: cost of the card's printing
:param date: when price was recorded
:param is_paper: is price for a paper printing or online printing
:param db_cursor: cursor of the database to retrieve data from
:param logger: logger to record any relevant info with
:return: None"""
def price_insert_query():
insert_query = sql.SQL('INSERT INTO {} ({}, {}, {}, {}, {}) VALUES (%s, %s, %s, %s, %s)').format(
sql.Identifier('prices', 'pricing'),
sql.Identifier('card'),
sql.Identifier('set'),
sql.Identifier('date'),
sql.Identifier('price'),
sql.Identifier('is_paper'))
db_cursor.execute(insert_query, (card, printing, date, price, is_paper))
warning_msg = f'Duplicate price insertion into prices.printing for card {card} from printing {printing} on {date}'
logger.info(f'Inserting card price for card {card}, printing {printing} on {date}')
su.execute_query(price_insert_query, logger, warning_msg, prod_mode)
def insert_into_tournament_entry(tourny_id, deck_archetype, deck_placement, player_name, deck_name,
placement_url, db_cursor, logger, prod_mode):
"""
:param tourny_id:
:param deck_archetype:
:param deck_placement:
:param player_name:
:param deck_name:
:param placement_url:
:param db_cursor:
:param logger:
:return:"""
def insert_query_func():
insert_query = sql.SQL('INSERT INTO {} ({}, {}, {}, {}, {}, {}) VALUES (%s, %s, %s, %s, %s, %s)').format(
sql.Identifier('events', 'event_entry'),
sql.Identifier('tourny_id'),
sql.Identifier('archetype'),
sql.Identifier('place'),
sql.Identifier('player'),
sql.Identifier('deck_name'),
sql.Identifier('url'))
db_cursor.execute(insert_query, (tourny_id, deck_archetype, deck_placement, player_name, deck_name,
placement_url))
warning_msg = f'Duplicate entry for tournament_entry attempted, for key {tourny_id}, {deck_archetype}, ' \
f'{deck_placement}, {player_name}'
su.execute_query(insert_query_func, logger, warning_msg, prod_mode)
def insert_card_cmc(card_name, cmc, db_cursor, logger, prod_mode):
def insert_query():
insert_query = ssu.get_n_item_insert_query(2).format(
sql.Identifier('cards', 'cmc'), sql.Identifier('card'),
sql.Identifier('cmc'))
db_cursor.execute(insert_query, (card_name, cmc))
logger.info(msg=f'Inserting cmc {cmc} for card {card_name}')
warning_msg = f'Duplicate entry for card {card_name} and cmc {cmc}'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_card_text(card_name, text, db_cursor, logger, prod_mode):
def insert_query():
insert_query = ssu.get_n_item_insert_query(2).format(
sql.Identifier('cards', 'text'), sql.Identifier('card'),
sql.Identifier('text'))
db_cursor.execute(insert_query, (card_name, text))
logger.info(msg=f'Inserting card text for card {card_name}')
warning_msg = f'Duplicate entry for card {card_name} and associated text'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_card_colors(card_name, colors, db_cursor, logger, prod_mode):
for color in colors:
def insert_query():
insert_query = ssu.get_n_item_insert_query(2).format(
sql.Identifier('cards', 'colors'), sql.Identifier('card'),
sql.Identifier('color'))
db_cursor.execute(insert_query, (card_name, color.lower()))
logger.info(f'Inserting color {color} for card {card_name}')
warning_msg = f'Duplicate entry for card {card_name} with color {color}'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_card_printings(card_name, sets, db_cursor, logger, prod_mode):
for printing in sets:
def insert_query():
insert_query = ssu.get_n_item_insert_query(2).format(
sql.Identifier('cards', 'printings'), sql.Identifier('card'),
sql.Identifier('set'))
db_cursor.execute(insert_query, (card_name, printing))
logger.info(msg=f'Inserting printing {printing} for card {card_name}')
warning_msg = f'Duplicate entry for card {card_name} and printing {printing}'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_set_data(db_cursor, code, full_name, release_date, size, logger,
prod_mode):
logger.info(f'Inserting set info for set {code}')
def temp():
insert_query = ssu.get_n_item_insert_query(4).format(
sql.Identifier('cards', 'set_info'), sql.Identifier('set'),
sql.Identifier('full_name'), sql.Identifier('release'),
sql.Identifier('size'))
db_cursor.execute(insert_query, (code, full_name, release_date, size))
su.execute_query(temp, logger, 'failed to retrieve set info', prod_mode)
def insert_card_pt(card_name, power, toughness, db_cursor, logger, prod_mode):
def insert_query():
insert_query = ssu.get_n_item_insert_query(3).format(
sql.Identifier('cards', 'pt'), sql.Identifier('card'),
sql.Identifier('power'), sql.Identifier('toughness'))
db_cursor.execute(insert_query, (card_name, power, toughness))
logger.info(
msg=
f'Inserting power {power}, toughness {toughness} info for card {card_name}'
)
warning_msg = f'Duplicate entry for for card {card_name} for power {power}, toughness {toughness}'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_card_types(card_name, type_line, db_cursor, logger, prod_mode):
types = [
card_type.lower() for card_type in type_line.split(' ')
if card_type not in INVALID_TYPES
]
for card_type in types:
if card_type != '—':
def insert_query():
insert_query = ssu.get_n_item_insert_query(2).format(
sql.Identifier('cards', 'types'), sql.Identifier('card'),
sql.Identifier('type'))
db_cursor.execute(insert_query, (card_name, card_type))
logger.info(msg=f'Inserting type {card_name} for card {card_name}')
warning_msg = f'Duplicate entry for card {card_name} with type {card_type}'
su.execute_query(insert_query, logger, warning_msg, prod_mode)
def insert_into_entry_card(entry_id, card_name, in_mainboard, quantity, db_cursor, logger, prod_mode):
"""
:param entry_id:
:param card_name:
:param in_mainboard:
:param quantity:
:param db_cursor:
:param logger:
:return:"""
def insert_query_func():
insert_query = sql.SQL('INSERT INTO {} ({}, {}, {}, {}) VALUES (%s, %s, %s, %s)').format(
sql.Identifier('events', 'entry_card'),
sql.Identifier('entry_id'),
sql.Identifier('card'),
sql.Identifier('mainboard'),
sql.Identifier('quantity'))
db_cursor.execute(insert_query, (entry_id, card_name, in_mainboard, quantity))
warning_msg = f'Duplicate entry for entry_card attempted: key {entry_id}, {card_name}, {in_mainboard}, {quantity}'
su.execute_query(insert_query_func, logger, warning_msg, prod_mode)
def insert_into_tournament_info(event_name, event_date, event_format, event_url, db_cursor, logger, prod_mode):
"""Inserts info for a tournament into the cursor of the given database. Assume size is None for now, can be lated
updated if needed
:param event_name: name of tournament
:param event_date: date tournament was held
:param event_format: format tournament was played in
:param event_url: url from which tournament info was pulled from
:param db_cursor: cursor of the database where info will be pushed
:param logger: logger by which info will be logged
:return: None"""
def insert_query_func():
insert_query = sql.SQL('INSERT INTO {} ({}, {}, {}, {}) VALUES (%s, %s, %s, %s)').format(
sql.Identifier('events', 'event_info'),
sql.Identifier('name'),
sql.Identifier('date'),
sql.Identifier('format'),
sql.Identifier('url'))
db_cursor.execute(insert_query, (event_name, event_date, event_format, event_url))
warning_msg = f'Duplicate entry for tournament_info attempted, key {event_name}, {event_date}'
su.execute_query(insert_query_func, logger, warning_msg, prod_mode)
