def _try_ancestor(self, db: DbWrapper):
        # For monsters with no series, try applying the series of the ancestor.
        monster_id_to_series_id = db.load_to_key_value('monster_id',
                                                       'series_id', 'monsters')
        monster_id_to_ancestor_id = db.load_to_key_value(
            'to_id', 'from_id', 'evolutions')
        for monster_id, series_id in monster_id_to_series_id.items():
            if series_id != 0:
                # Series already set.
                continue

            ancestor_id = monster_id_to_ancestor_id.get(monster_id)
            if ancestor_id is None:
                # Monster had no ancestor to look up the series of.
                continue

            ancestor_series_id = monster_id_to_series_id[ancestor_id]
            if ancestor_series_id == 0:
                # Ancestor also has no series.
                continue

            # Apply the ancestor series to the current monster
            item = MonsterWithSeries(monster_id=monster_id,
                                     series_id=ancestor_series_id)
            db.insert_or_update(item)
示例#2
0
    def _try_ancestor(self, db: DbWrapper):
        # For monsters with no series, try applying the series of the ancestor.
        monster_id_to_series_id = db.load_to_key_value('monster_id', 'series_id', 'monster_series', 'priority = 1')
        monster_id_to_ancestor_id = db.load_to_key_value('to_id', 'from_id', 'evolutions')
        for csc in self.data.ownable_cards:
            monster_id = csc.monster_id
            series_id = monster_id_to_series_id.get(monster_id, 0)

            if series_id != 0:
                # Series already set.
                continue

            ancestor_id = monster_id_to_ancestor_id.get(monster_id)
            if ancestor_id is None:
                # Monster had no ancestor to look up the series of.
                continue

            ancestor_series_id = monster_id_to_series_id.get(ancestor_id, 0)
            if ancestor_series_id == 0:
                # Ancestor also has no series.
                continue

            # Apply the ancestor series to the current monster
            item = MonsterSeries(monster_id=monster_id, series_id=ancestor_series_id, priority=True)
            db.insert_or_update(item)
示例#3
0
def do_migration(csd: crossed_data.CrossServerDatabase, db: DbWrapper):
    get_series_sql = ('SELECT tsr_seq AS series_id, name_jp, name_us AS name_na, name_kr'
                      ' FROM padguide.series_list'
                      ' WHERE del_yn = 0')

    data = db.fetch_data(get_series_sql)

    for row in data:
        series_id = row['series_id']
        if series_id == 42:
            # Not importing 42 (premium) which was used as the old unsorted
            continue

        item = Series(series_id=series_id,
                      name_jp=row['name_jp'],
                      name_na=row['name_na'],
                      name_kr=row['name_kr'])
        db.insert_or_update(item)

    monsterno_seriesid_map = db.load_to_key_value('monster_no', 'tsr_seq', 'padguide.monster_info_list')
    monsterno_nameoverride_map = db.load_to_key_value('monster_no', 'tm_name_us_override', 'padguide.monster_list')
    monsterno_regdate_map = db.load_to_key_value('monster_no', 'reg_date', 'padguide.monster_list')

    for csc in csd.ownable_cards:
        monster_id = csc.monster_id
        if csc.jp_card.server == Server.na:
            # Handle Voltron.
            monster_no = na_id_to_monster_no(csc.na_card.card.monster_no)
        elif csc.jp_card.server != Server.jp:
            raise ValueError('Unexpected failure')
        else:
            # Since this is a JP card for sure, monster_id == JP monster_no
            monster_no = jp_id_to_monster_no(monster_id)

        # Series processing
        series_id = monsterno_seriesid_map[monster_no]
        if series_id == 42:
            series_id = 0  # Map premium to unsorted

        update_sql = 'UPDATE monsters SET series_id={} WHERE monster_id={}'.format(series_id, monster_id)
        db.insert_item(update_sql)

        # Reg Date processing
        reg_date = monsterno_regdate_map[monster_no]
        update_sql = "UPDATE monsters SET reg_date='{}' WHERE monster_id={}".format(reg_date.date().isoformat(),
                                                                                    monster_id)
        db.insert_item(update_sql)

        # NA name override processing
        name_override = monsterno_nameoverride_map.get(monster_no, None)
        if name_override:
            name_override = name_override.replace("'", "''")
            update_sql = "UPDATE monsters SET name_na_override='{}' WHERE monster_id={}".format(name_override,
                                                                                                monster_id)
            db.insert_item(update_sql)
    def _try_group(self, db: DbWrapper):
        # Try to infer the series of a monster via the series of monsters in its group.
        monster_id_to_series_id = db.load_to_key_value('monster_id',
                                                       'series_id', 'monsters')

        # Partition existing DadGuide monster series by PAD group ID.
        group_id_to_series_ids = defaultdict(set)
        for csc in self.data.ownable_cards:
            monster_id = csc.monster_id
            series_id = monster_id_to_series_id[monster_id]
            if series_id == 0:
                # No useful data from this card
                continue

            group_id = csc.jp_card.card.group_id
            group_id_to_series_ids[group_id].add(series_id)

        # Now loop through again and see if we can apply any series via group mapping.
        for csc in self.data.ownable_cards:
            monster_id = csc.monster_id
            series_id = monster_id_to_series_id[monster_id]
            if series_id != 0:
                # Series already set.
                continue

            group_id = csc.jp_card.card.group_id
            possible_series = group_id_to_series_ids[group_id]
            if len(possible_series) == 1:
                group_series_id = list(possible_series)[0]
                item = MonsterWithSeries(monster_id=monster_id,
                                         series_id=group_series_id)
                db.insert_or_update(item)