artemis/titles/sao/read.py

import csv
from os import path
from typing import Optional

from core.config import CoreConfig
from read import BaseReader
from titles.sao.const import SaoConstants
from titles.sao.database import SaoData


class SaoReader(BaseReader):
    def __init__(
        self,
        config: CoreConfig,
        version: int,
        bin_arg: Optional[str],
        opt_arg: Optional[str],
        extra: Optional[str],
    ) -> None:
        super().__init__(config, version, bin_arg, opt_arg, extra)
        self.data = SaoData(config)

        try:
            self.logger.info(
                f"Start importer for {SaoConstants.game_ver_to_string(version)}"
            )
        except IndexError:
            self.logger.error(f"Invalid project SAO version {version}")
            exit(1)

    async def read(self) -> None:
        if path.exists(self.bin_dir):
            await self.read_csv(f"{self.bin_dir}")

        else:
            self.logger.warn("Directory not found, nothing to import")

    async def read_csv(self, bin_dir: str) -> None:
        self.logger.info(f"Read csv from {bin_dir}")

        self.logger.info("Now reading QuestScene.csv")
        try:
            fullPath = bin_dir + "/QuestScene.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    questSceneId = row["QuestSceneId"]
                    sortNo = row["SortNo"]
                    name = row["Name"]
                    enabled = True

                    self.logger.info(f"Added quest {questSceneId} | Name: {name}")

                    try:
                        await self.data.static.put_quest(
                            questSceneId, 0, sortNo, name, enabled
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading HeroLog.csv")
        try:
            fullPath = bin_dir + "/HeroLog.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    heroLogId = row["HeroLogId"]
                    name = row["Name"]
                    nickname = row["Nickname"]
                    rarity = row["Rarity"]
                    skillTableSubId = row["SkillTableSubId"]
                    awakeningExp = row["AwakeningExp"]
                    flavorText = row["FlavorText"]
                    enabled = True

                    self.logger.info(f"Added hero {heroLogId} | Name: {name}")

                    try:
                        await self.data.static.put_hero(
                            0,
                            heroLogId,
                            name,
                            nickname,
                            rarity,
                            skillTableSubId,
                            awakeningExp,
                            flavorText,
                            enabled,
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading Equipment.csv")
        try:
            fullPath = bin_dir + "/Equipment.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    equipmentId = row["EquipmentId"]
                    equipmentType = row["EquipmentType"]
                    weaponTypeId = row["WeaponTypeId"]
                    name = row["Name"]
                    rarity = row["Rarity"]
                    flavorText = row["FlavorText"]
                    enabled = True

                    self.logger.info(f"Added equipment {equipmentId} | Name: {name}")

                    try:
                        await self.data.static.put_equipment(
                            0,
                            equipmentId,
                            name,
                            equipmentType,
                            weaponTypeId,
                            rarity,
                            flavorText,
                            enabled,
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading Item.csv")
        try:
            fullPath = bin_dir + "/Item.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    itemId = row["ItemId"]
                    itemTypeId = row["ItemTypeId"]
                    name = row["Name"]
                    rarity = row["Rarity"]
                    flavorText = row["FlavorText"]
                    enabled = True

                    self.logger.info(f"Added item {itemId} | Name: {name}")

                    try:
                        await self.data.static.put_item(
                            0, itemId, name, itemTypeId, rarity, flavorText, enabled
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading SupportLog.csv")
        try:
            fullPath = bin_dir + "/SupportLog.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    supportLogId = row["SupportLogId"]
                    charaId = row["CharaId"]
                    name = row["Name"]
                    rarity = row["Rarity"]
                    salePrice = row["SalePrice"]
                    skillName = row["SkillName"]
                    enabled = True

                    self.logger.info(f"Added support log {supportLogId} | Name: {name}")

                    try:
                        await self.data.static.put_support_log(
                            0,
                            supportLogId,
                            charaId,
                            name,
                            rarity,
                            salePrice,
                            skillName,
                            enabled,
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading Title.csv")
        try:
            fullPath = bin_dir + "/Title.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    titleId = row["TitleId"]
                    displayName = row["DisplayName"]
                    requirement = row["Requirement"]
                    rank = row["Rank"]
                    imageFilePath = row["ImageFilePath"]
                    enabled = True

                    self.logger.info(f"Added title {titleId} | Name: {displayName}")

                    if len(titleId) > 5:
                        try:
                            await self.data.static.put_title(
                                0,
                                titleId,
                                displayName,
                                requirement,
                                rank,
                                imageFilePath,
                                enabled,
                            )
                        except Exception as err:
                            self.logger.error(err)
                    elif (
                        len(titleId) < 6
                    ):  # current server code cannot have multiple lengths for the id
                        continue
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")

        self.logger.info("Now reading RareDropTable.csv")
        try:
            fullPath = bin_dir + "/RareDropTable.csv"
            with open(fullPath, encoding="UTF-8") as fp:
                reader = csv.DictReader(fp)
                for row in reader:
                    questRareDropId = row["QuestRareDropId"]
                    commonRewardId = row["CommonRewardId"]
                    enabled = True

                    self.logger.info(
                        f"Added rare drop {questRareDropId} | Reward: {commonRewardId}"
                    )

                    try:
                        await self.data.static.put_rare_drop(
                            0, questRareDropId, commonRewardId, enabled
                        )
                    except Exception as err:
                        self.logger.error(err)
        except Exception:
            self.logger.warning(f"Couldn't read csv file in {self.bin_dir}, skipping")