deckinfo

src/app.controller.ts

@@ -118,7 +118,14 @@ export class AppController {
     const result = await this.appService.getRandomVote(userid);
     return result;
   }
-
+  @Get('deckinfo')
+  async getDeckInfo(@Query() query, @Res() res: express.Response) {
+    if (!query.name) {
+      res.status(404).send('deck name is required!');
+    }
+    const result = await this.appService.getDeckInfo(query);
+    res.status(result.code).json(result);
+  }
   @Post('upload')
   uploadFile(@Req() req: express.Request, @Res() res: express.Response) {
     const form = new IncomingForm();
@@ -147,14 +154,6 @@ export class AppController {
       res.status(response.code).json(response);
     });
   }
-  @Get('deckinfo')
-  async getDeckInfo(@Query() query, @Res() res: express.Response) {
-    if (!query.name) {
-      res.status(404).send('deck name is required!');
-    }
-    const result = await this.appService.getDeckInfo(query);
-    res.status(result.code).json(result);
-  }
   @Get('download/:id')
   downloadFile(@Param('id') filename: string, @Res() res: express.Response) {
     if (!filename) {
@@ -163,4 +162,19 @@ export class AppController {
     const filepath = `upload/${filename}`;
     res.download(filepath, filename);
   }
+
+  @Get('deckdata/:id')
+  async getDeckData(
+    @Param('id') filename: string,
+    @Res() res: express.Response,
+  ) {
+    if (!filename) {
+      res.status(400).end('Missing filename.');
+    }
+    const deck = await this.appService.getDeckData(filename);
+    if (!deck) {
+      res.status(404).end('File not found.');
+    }
+    res.json({ deck });
+  }
 }

src/app.service.ts

@@ -93,6 +93,13 @@ interface VoteOption {
   percentage: number;
 }
 
+interface DeckInfoCard {
+  id: number;
+  num: number;
+  name?: string;
+  type?: string;
+}
+
 @Injectable()
 export class AppService {
   chineseDirtyFilter: Filter;
@@ -1155,4 +1162,129 @@ export class AppService {
       data: deck,
     };
   }
+
+  private async fillCardInfo(item: DeckInfoCard) {
+    const lang = 'cn';
+    const id = item.id;
+    const card = await this.cndb.getRepository(YGOProDatabaseDatas).findOne({
+      where: { id },
+      relations: ['texts'],
+    });
+    if (!card) {
+      this.log.error(`Card ${item.id} not found in database.`);
+      item.name = 'Not found in database';
+      item.type = '怪兽';
+      return;
+    }
+    item.name = card.texts.name;
+    item.type = getStringValueByMysticalNumber(lang, typeOffset, card.type);
+  }
+
+  private async fillCardInfoBatch(arr: DeckInfoCard[]) {
+    return await Promise.all(arr.map((item) => this.fillCardInfo(item)));
+  }
+
+  async getDeckData(filename: string) {
+    const filepath = 'upload/' + filename;
+
+    let contentsRaw: string;
+    try {
+      contentsRaw = await fs.readFile(filepath, 'utf8');
+    } catch (e) {
+      return null;
+    }
+
+    const contents = contentsRaw.split(/\r?\n/);
+
+    const mainCardArr: DeckInfoCard[] = [];
+    const extraCardArr: DeckInfoCard[] = [];
+    const sideCardArr: DeckInfoCard[] = [];
+
+    const masterCardArr: DeckInfoCard[] = [];
+    const trapCardArr: DeckInfoCard[] = [];
+    const spellCardArr: DeckInfoCard[] = [];
+
+    const mainOriginal: number[] = [];
+    const extraOriginal: number[] = [];
+    const sideOriginal: number[] = [];
+
+    let current = mainOriginal;
+
+    _.each(contents, function (text) {
+      if (text === '#main') {
+        current = mainOriginal;
+      }
+      if (text === '#extra') {
+        current = extraOriginal;
+      }
+      if (text === '!side') {
+        current = sideOriginal;
+      }
+
+      if (text === '#main' || text === '#extra' || text === '!side') {
+        return;
+      }
+
+      if (text.indexOf('created') !== -1) {
+        return;
+      }
+
+      if (text.trim() === '') {
+        return;
+      }
+      const parsedText = parseInt(text);
+      if (isNaN(parsedText)) {
+        return;
+      }
+      current.push(parsedText);
+    });
+
+    const main = _.countBy(mainOriginal, Math.floor);
+    const extra = _.countBy(extraOriginal, Math.floor);
+    const side = _.countBy(sideOriginal, Math.floor);
+
+    _.each(main, function (value, key) {
+      mainCardArr.push({
+        id: parseInt(key),
+        num: value,
+      });
+    });
+
+    _.each(extra, function (value, key) {
+      extraCardArr.push({
+        id: parseInt(key),
+        num: value,
+      });
+    });
+
+    _.each(side, function (value, key) {
+      sideCardArr.push({
+        id: parseInt(key),
+        num: value,
+      });
+    });
+    await Promise.all(
+      [mainCardArr, sideCardArr, extraCardArr].map((arr) =>
+        this.fillCardInfoBatch(arr),
+      ),
+    );
+    for (const item of mainCardArr) {
+      if (item.type === '怪兽') {
+        masterCardArr.push(item);
+      } else if (item.type === '魔法') {
+        spellCardArr.push(item);
+      } else if (item.type === '陷阱') {
+        trapCardArr.push(item);
+      } else {
+        masterCardArr.push(item);
+      }
+    }
+    return {
+      monster: masterCardArr,
+      spells: spellCardArr,
+      traps: trapCardArr,
+      extra: extraCardArr,
+      side: sideCardArr,
+    };
+  }
 }

src/entities/ygodb/YGOProDatabaseDatas.ts

-import { Column, Entity } from 'typeorm';
+import { Column, Entity, OneToOne } from 'typeorm';
+import { YGOProDatabaseTexts } from './YGOProDatabaseTexts';
 
 @Entity('datas')
 export class YGOProDatabaseDatas {
   @Column('integer', { primary: true, name: 'id' })
-  id: number | null;
+  id: number;
+
+  @OneToOne((type) => YGOProDatabaseTexts, (texts) => texts.datas)
+  texts: YGOProDatabaseTexts;
 
   @Column('integer', { name: 'ot', nullable: true })
   ot: number | null;

src/entities/ygodb/YGOProDatabaseTexts.ts

-import { Column, Entity } from 'typeorm';
+import { Column, Entity, OneToOne } from 'typeorm';
+import { YGOProDatabaseDatas } from './YGOProDatabaseDatas';
+import { JoinColumn } from 'typeorm';
 
 @Entity('texts')
 export class YGOProDatabaseTexts {
   @Column('integer', { primary: true, name: 'id' })
   id: number;
 
+  @OneToOne((type) => YGOProDatabaseDatas, (datas) => datas.texts)
+  @JoinColumn({ name: 'id', referencedColumnName: 'id' })
+  datas: YGOProDatabaseDatas;
+
   @Column('text', { name: 'name', nullable: true })
   name: string | null;