Initial commit

db_engine.py

@@ -0,0 +1,462 @@
+import math
+from datetime import datetime
+import logging
+import os
+
+from peewee import *
+
+db = SqliteDatabase(
+    'storage/pd_master.db',
+    pragmas={
+        'journal_mode': 'wal',
+        'cache_size': -1 * 64000,
+        'synchronous': 0
+    }
+)
+
+date = f'{datetime.now().year}-{datetime.now().month}-{datetime.now().day}'
+log_level = logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
+logging.basicConfig(
+    filename=f'logs/{date}.log',
+    format='%(asctime)s - database - %(levelname)s - %(message)s',
+    level=log_level
+)
+
+
+class BaseModel(Model):
+    class Meta:
+        database = db
+
+
+class Current(BaseModel):
+    season = IntegerField()
+    week = IntegerField(default=0)
+    gsheet_template = CharField()
+    gsheet_version = CharField()
+    live_scoreboard = IntegerField()
+
+    @staticmethod
+    def latest():
+        latest_current = Current.select().order_by(-Current.id).get()
+        return latest_current
+
+
+db.create_tables([Current])
+
+
+class Rarity(BaseModel):
+    value = IntegerField()
+    name = CharField(unique=True)
+    color = CharField()
+
+    def __str__(self):
+        return self.name
+
+
+db.create_tables([Rarity])
+
+
+class Event(BaseModel):
+    name = CharField()
+    short_desc = CharField(null=True)
+    url = CharField(null=True)
+    long_desc = CharField(null=True)
+    thumbnail = CharField(null=True)
+    active = BooleanField(default=False)
+
+
+db.create_tables([Event])
+
+
+class Cardset(BaseModel):
+    name = CharField()
+    description = CharField()
+    event = ForeignKeyField(Event, null=True)
+    for_purchase = BooleanField(default=True)  # for_purchase
+    total_cards = IntegerField()
+    in_packs = BooleanField(default=True)
+    ranked_legal = BooleanField(default=True)
+
+    def __str__(self):
+        return self.name
+
+
+db.create_tables([Cardset])
+
+
+class Player(BaseModel):
+    player_id = IntegerField(primary_key=True)
+    p_name = CharField()
+    cost = IntegerField(default=0)
+    image = CharField()
+    image2 = CharField(null=True)
+    mlbclub = CharField()
+    franchise = CharField()
+    cardset = ForeignKeyField(Cardset)
+    set_num = IntegerField()
+    rarity = ForeignKeyField(Rarity)
+    pos_1 = CharField()
+    pos_2 = CharField(null=True)
+    pos_3 = CharField(null=True)
+    pos_4 = CharField(null=True)
+    pos_5 = CharField(null=True)
+    pos_6 = CharField(null=True)
+    pos_7 = CharField(null=True)
+    pos_8 = CharField(null=True)
+    headshot = CharField(null=True)
+    vanity_card = CharField(null=True)
+    strat_code = CharField(null=True)
+    bbref_id = CharField(null=True)
+    fangr_id = CharField(null=True)
+    description = CharField()
+    quantity = IntegerField(default=999)
+
+    def __str__(self):
+        return f'{self.cardset} {self.p_name} ({self.rarity.name})'
+
+    # def __eq__(self, other):
+    #     if self.cardset.id == other.cardset.id and self.name == other.name:
+    #         return True
+    #     else:
+    #         return False
+
+    def __lt__(self, other):
+        if self.wara < other.wara:
+            return True
+        elif self.wara > other.wara:
+            return False
+        elif self.name < other.name:
+            return True
+        else:
+            return False
+
+    def get_all_pos(self):
+        all_pos = []
+
+        if self.pos_1 and self.pos_1 != 'CP':
+            all_pos.append(self.pos_1)
+        if self.pos_2 and self.pos_2 != 'CP':
+            all_pos.append(self.pos_2)
+        if self.pos_3 and self.pos_3 != 'CP':
+            all_pos.append(self.pos_3)
+        if self.pos_4 and self.pos_4 != 'CP':
+            all_pos.append(self.pos_4)
+        if self.pos_5 and self.pos_5 != 'CP':
+            all_pos.append(self.pos_5)
+        if self.pos_6 and self.pos_6 != 'CP':
+            all_pos.append(self.pos_6)
+        if self.pos_7 and self.pos_7 != 'CP':
+            all_pos.append(self.pos_7)
+        if self.pos_8 and self.pos_8 != 'CP':
+            all_pos.append(self.pos_8)
+
+        return all_pos
+
+    def change_on_sell(self):
+        # caps = {
+        #     'replacement': 15,
+        #     'reserve': 50,
+        #     'starter': 200,
+        #     'all-star': 750,
+        #     'mvp': 2500,
+        #     'hof': 999999999
+        # }
+        logging.info(f'{self.p_name} cost changing from: {self.cost}')
+        self.cost = max(math.floor(self.cost * .95), 1)
+        # if self.quantity != 999:
+        #     self.quantity += 1
+        logging.info(f'{self.p_name} cost now: {self.cost}')
+        self.save()
+
+    def change_on_buy(self):
+        logging.info(f'{self.p_name} cost changing from: {self.cost}')
+        self.cost = math.ceil(self.cost * 1.1)
+        # if self.quantity != 999:
+        #     self.quantity -= 1
+        logging.info(f'{self.p_name} cost now: {self.cost}')
+        self.save()
+
+
+db.create_tables([Player])
+
+
+class Team(BaseModel):
+    abbrev = CharField()
+    sname = CharField()
+    lname = CharField()
+    gmid = IntegerField()
+    gmname = CharField()
+    gsheet = CharField()
+    wallet = IntegerField()
+    team_value = IntegerField()
+    collection_value = IntegerField()
+    logo = CharField(null=True)
+    color = CharField(null=True)
+    season = IntegerField()
+    event = ForeignKeyField(Event, null=True)
+    career = IntegerField(default=0)
+    ranking = IntegerField(default=1000)
+    has_guide = BooleanField(default=False)
+    is_ai = IntegerField(null=True)
+
+    def __str__(self):
+        return f'S{self.season} {self.lname}'
+
+    @staticmethod
+    def get_by_owner(gmid, season=None):
+        if not season:
+            season = Current.get().season
+        team = Team.get_or_none((Team.gmid == gmid) & (Team.season == season))
+
+        if not team:
+            return None
+
+        return team
+
+    @staticmethod
+    def select_season(season=None):
+        if not season:
+            season = Current.get().season
+        return Team.select().where(Team.season == season)
+
+    @staticmethod
+    def get_season(abbrev, season=None):
+        if not season:
+            season = Current.get().season
+        return Team.get_or_none(Team.season == season, Team.abbrev == abbrev.upper())
+
+    def team_hash(self):
+        hash_string = f'{self.abbrev}{self.gmid / 123:.0f}'
+        logging.info(f'string: {hash_string}')
+        return hash(hash_string)
+
+
+db.create_tables([Team])
+
+
+class PackType(BaseModel):
+    name = CharField()
+    card_count = IntegerField()
+    description = CharField()
+    cost = IntegerField()
+    available = BooleanField(default=True)
+
+
+db.create_tables([PackType])
+
+
+class Pack(BaseModel):
+    team = ForeignKeyField(Team)
+    pack_type = ForeignKeyField(PackType)
+    open_time = DateTimeField(null=True)
+
+
+db.create_tables([Pack])
+
+
+class Card(BaseModel):
+    player = ForeignKeyField(Player, null=True)
+    team = ForeignKeyField(Team, null=True)
+    pack = ForeignKeyField(Pack, null=True)
+    value = IntegerField(default=0)
+
+    def __str__(self):
+        if self.player:
+            return f'{self.player} - {self.team.sname}'
+        else:
+            return f'Blank - {self.team.sname}'
+
+    @staticmethod
+    def select_season(season):
+        return Card.select().join(Team).where(Card.team.season == season)
+
+
+db.create_tables([Card])
+
+
+class Roster(BaseModel):
+    team = ForeignKeyField(Team)
+    name = CharField()
+    roster_num = IntegerField()
+    card_1 = ForeignKeyField(Card)
+    card_2 = ForeignKeyField(Card)
+    card_3 = ForeignKeyField(Card)
+    card_4 = ForeignKeyField(Card)
+    card_5 = ForeignKeyField(Card)
+    card_6 = ForeignKeyField(Card)
+    card_7 = ForeignKeyField(Card)
+    card_8 = ForeignKeyField(Card)
+    card_9 = ForeignKeyField(Card)
+    card_10 = ForeignKeyField(Card)
+    card_11 = ForeignKeyField(Card)
+    card_12 = ForeignKeyField(Card)
+    card_13 = ForeignKeyField(Card)
+    card_14 = ForeignKeyField(Card)
+    card_15 = ForeignKeyField(Card)
+    card_16 = ForeignKeyField(Card)
+    card_17 = ForeignKeyField(Card)
+    card_18 = ForeignKeyField(Card)
+    card_19 = ForeignKeyField(Card)
+    card_20 = ForeignKeyField(Card)
+    card_21 = ForeignKeyField(Card)
+    card_22 = ForeignKeyField(Card)
+    card_23 = ForeignKeyField(Card)
+    card_24 = ForeignKeyField(Card)
+    card_25 = ForeignKeyField(Card)
+    card_26 = ForeignKeyField(Card)
+
+    def __str__(self):
+        return f'{self.team} Roster'
+
+    # def get_cards(self, team):
+    #     all_cards = Card.select().where(Card.roster == self)
+    #     this_roster = []
+    #     return [this_roster.card1, this_roster.card2, this_roster.card3, this_roster.card4, this_roster.card5,
+    #             this_roster.card6, this_roster.card7, this_roster.card8, this_roster.card9, this_roster.card10,
+    #             this_roster.card11, this_roster.card12, this_roster.card13, this_roster.card14, this_roster.card15,
+    #             this_roster.card16, this_roster.card17, this_roster.card18, this_roster.card19, this_roster.card20,
+    #             this_roster.card21, this_roster.card22, this_roster.card23, this_roster.card24, this_roster.card25,
+    #             this_roster.card26]
+
+
+class BattingStat(BaseModel):
+    card = ForeignKeyField(Card)
+    team = ForeignKeyField(Team)
+    roster_num = IntegerField()
+    vs_team = ForeignKeyField(Team)
+    pos = CharField()
+    pa = IntegerField()
+    ab = IntegerField()
+    run = IntegerField()
+    hit = IntegerField()
+    rbi = IntegerField()
+    double = IntegerField()
+    triple = IntegerField()
+    hr = IntegerField()
+    bb = IntegerField()
+    so = IntegerField()
+    hbp = IntegerField()
+    sac = IntegerField()
+    ibb = IntegerField()
+    gidp = IntegerField()
+    sb = IntegerField()
+    cs = IntegerField()
+    bphr = IntegerField()
+    bpfo = IntegerField()
+    bp1b = IntegerField()
+    bplo = IntegerField()
+    xch = IntegerField()
+    xhit = IntegerField()
+    error = IntegerField()
+    pb = IntegerField()
+    sbc = IntegerField()
+    csc = IntegerField()
+    week = IntegerField()
+    season = IntegerField()
+    created = DateTimeField()
+    game_id = IntegerField()
+
+
+class PitchingStat(BaseModel):
+    card = ForeignKeyField(Card)
+    team = ForeignKeyField(Team)
+    roster_num = IntegerField()
+    vs_team = ForeignKeyField(Team)
+    ip = FloatField()
+    hit = IntegerField()
+    run = IntegerField()
+    erun = IntegerField()
+    so = IntegerField()
+    bb = IntegerField()
+    hbp = IntegerField()
+    wp = IntegerField()
+    balk = IntegerField()
+    hr = IntegerField()
+    ir = IntegerField()
+    irs = IntegerField()
+    gs = IntegerField()
+    win = IntegerField()
+    loss = IntegerField()
+    hold = IntegerField()
+    sv = IntegerField()
+    bsv = IntegerField()
+    week = IntegerField()
+    season = IntegerField()
+    created = DateTimeField()
+    game_id = IntegerField()
+
+
+class Result(BaseModel):
+    away_team = ForeignKeyField(Team)
+    home_team = ForeignKeyField(Team)
+    away_score = IntegerField()
+    home_score = IntegerField()
+    away_team_value = IntegerField(null=True)
+    home_team_value = IntegerField(null=True)
+    away_team_ranking = IntegerField(null=True)
+    home_team_ranking = IntegerField(null=True)
+    scorecard = CharField()
+    week = IntegerField()
+    season = IntegerField()
+    ranked = BooleanField()
+    short_game = BooleanField()
+    game_type = CharField(null=True)
+
+    @staticmethod
+    def select_season(season=None):
+        if not season:
+            season = Current.get().season
+        return Result.select().where(Result.season == season)
+
+
+class Award(BaseModel):
+    name = CharField()
+    season = IntegerField()
+    timing = CharField(default="In-Season")
+    card = ForeignKeyField(Card, null=True)
+    team = ForeignKeyField(Team, null=True)
+    image = CharField(null=True)
+
+
+class Paperdex(BaseModel):
+    team = ForeignKeyField(Team)
+    player = ForeignKeyField(Player)
+    created = DateTimeField(default=int(datetime.timestamp(datetime.now())*1000))
+
+    # def add_to_paperdex(self, team, cards: list):
+    #     for x in players:
+    #         if not isinstance(x, Card):
+    #             raise TypeError(f'The Pokedex can only take a list of Player or Card objects')
+    #
+    #         Paperdex.get_or_create(team=team, player=player)
+
+
+class Reward(BaseModel):
+    name = CharField(null=True)
+    season = IntegerField()
+    week = IntegerField()
+    team = ForeignKeyField(Team)
+    created = DateTimeField()
+
+
+class GameRewards(BaseModel):
+    name = CharField()
+    pack_type = ForeignKeyField(PackType, null=True)
+    player = ForeignKeyField(Player, null=True)
+    money = IntegerField(null=True)
+
+
+class Notification(BaseModel):
+    created = DateTimeField()
+    title = CharField()
+    desc = CharField(null=True)
+    field_name = CharField()
+    message = CharField()
+    about = CharField()  # f'{Topic}-{Object ID}'
+    ack = BooleanField(default=False)
+
+
+db.create_tables(
+    [Roster, BattingStat, PitchingStat, Result, Award, Paperdex, Reward, GameRewards, Notification]
+)
+db.close()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+peewee
+python-multipart
+pandas
+pygsheets