src/api.ts

   1 import { HttpServer } from './lib/server';
   2 import * as config from './config';
   3 import { AccountRepository } from './repository/accounts';
   4 import { CityRepository } from './repository/city';
   5 import { MailRepository } from './repository/mail';
   6 import {BadInputError, ERROR_CODE, NotFoundError} from './errors';
   7 import { renderKingomOverview } from './render/kingdom-overview';
   8 import { renderLandDevelopment } from './render/land-development';
   9 import { tick } from './tasks/tick';
  10 import { construction } from './tasks/construction';
  11 import { unitTraining } from './tasks/unit-training';
  12 import { fight } from './tasks/fight';
  13 import { renderUnitTraining } from './render/unit-training';
  14 import { launchOffensive, listOperations, renderOverworldMap } from './render/fight';
  15 import { createBullBoard } from '@bull-board/api';
  16 import { BullAdapter } from '@bull-board/api/bullAdapter';
  17 import _ from 'lodash';
  18 import { renderMailroom, renderMessage } from './render/mail';
  19
  20 const server = new HttpServer(config.API_PORT);
  21
  22 const accountRepo = new AccountRepository();
  23 const cityRepo = new CityRepository();
  24 const mailRepo = new MailRepository();
  25
  26 createBullBoard({
  27         queues: [
  28                 new BullAdapter(tick.queue),
  29                 new BullAdapter(construction.queue),
  30                 new BullAdapter(unitTraining.queue),
  31                 new BullAdapter(fight.queue)
  32         ],
  33         serverAdapter: server.bullAdapter,
  34 });
  35
  36 server.post<{
  37         body: {username: string, password: string}},
  38         string
  39         >
  40         ('/accounts', async (req) => {
  41         const { username, password} = req.body;
  42         if(!username || !password || username.length < 3 || password.length < 3) {
  43                 throw new BadInputError('Invalid username or password', ERROR_CODE.INVALID_USERNAME);
  44         }
  45         const acct = await accountRepo.create(username, password);
  46
  47         // lets create the city!
  48         await cityRepo.create(acct.id);
  49
  50         return `<p>You are all signed up! You can go ahead and log in</p>`;
  51 });
  52
  53 server.post<{body: {username: string, password: string}}, void>('/login', async (req, raw, res) => {
  54         const { username, password} = req.body;
  55         if(!username || !password || username.length < 3 || password.length < 3) {
  56                 throw new BadInputError('Invalid username or password', ERROR_CODE.INVALID_USERNAME);
  57         }
  58         const {account, session} = await accountRepo.login(username, password);
  59         if(!account) {
  60                 throw new NotFoundError('Invalid username or password', ERROR_CODE.USER_NOT_FOUND);
  61         }
  62
  63         res.setHeader('hx-redirect', `/game.html?token=${session.id}&id=${session.account_id}`);
  64
  65 });
  66
  67 server.post<{body: {
  68         soldiers: number,
  69         attackers: number,
  70         defenders: number,
  71         sp_attackers: number,
  72         sp_defenders: number
  73   }}, string>('/attack-power', async req => {
  74         const power = await cityRepo.power(req.body);
  75
  76         return power.toLocaleString();
  77
  78 });
  79
  80 server.get<{params: { cityId: string }}, string>('/city/:cityId', async req => {
  81         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
  82         const yourCity = await cityRepo.FindOne({ owner: account.id });
  83         const city = await cityRepo.FindOne({ id: req.params.cityId });
  84         const acct = await accountRepo.FindOne({id: city.owner});
  85
  86
  87         return await launchOffensive(city, acct || {
  88                 id: '-',
  89                 username: 'Rebels',
  90                 password: ''
  91         }, yourCity, account);
  92 });
  93
  94 server.get<{}, string>('/poll/overview', async req => {
  95         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
  96         const city = await cityRepo.FindOne({ owner: account.id });
  97
  98         return renderKingomOverview(city, account);
  99 });
 100
 101 server.get<{}, string>('/poll/construction', async req => {
 102         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 103         const city = await cityRepo.FindOne({ owner: account.id });
 104         const buildings = await cityRepo.buildingRepository.list();
 105
 106         const buildQueues = await cityRepo.getBuildQueues(account.id);
 107         return renderLandDevelopment(city, buildings, buildQueues);
 108 });
 109
 110 server.get<{}, string>('/poll/unit-training', async req => {
 111         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 112         const city = await cityRepo.FindOne({ owner: account.id });
 113
 114         const unitTrainingQueues = await cityRepo.getUnitTrainingQueues(account.id);
 115         const units = await cityRepo.unitRepository.list();
 116
 117         return renderUnitTraining(city, units, unitTrainingQueues);
 118 });
 119
 120 server.get<{}, string>('/poll/map', async req => {
 121         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 122         const city = await cityRepo.FindOne({ owner: account.id });
 123
 124         return renderOverworldMap(await cityRepo.FindAll(), city);
 125 });
 126
 127 server.get<{}, string>('/poll/mailroom', async req => {
 128         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 129
 130         return renderMailroom(await mailRepo.listReceivedMessages(account.id));
 131 });
 132
 133
 134 server.post<{
 135         body: {
 136                 amount: string,
 137                 building_type: string
 138         }
 139 }, string>('/cost/construction', async req => {
 140         const amount = parseInt(req.body.amount, 10);
 141         const building = await cityRepo.buildingRepository.findBySlug(req.body.building_type);
 142
 143         if(!building) {
 144                 throw new NotFoundError(`Invalid building type ${req.body.building_type}`, ERROR_CODE.INVALID_BUILDING);
 145         }
 146
 147         return JSON.stringify({
 148                 gold: building.gold * amount,
 149                 ore: building.ore * amount,
 150                 logs: building.logs * amount,
 151                 land: building.land * amount,
 152                 time: building.time
 153         });
 154 });
 155
 156 server.post<{
 157         body: {
 158                 amount: string;
 159                 type: string;
 160         }
 161 }, string>('/cost/training', async req => {
 162         const amount = parseInt(req.body.amount, 10);
 163         const unit = await cityRepo.unitRepository.findBySlug(req.body.type);
 164
 165         if(!unit) {
 166                 throw new NotFoundError(`Invalid unit type ${req.body.type}`, ERROR_CODE.INVALID_UNIT);
 167         }
 168
 169         return JSON.stringify({
 170                 population: unit.population * amount,
 171                 soldiers: unit.soldiers * amount,
 172                 attackers: unit.attackers * amount,
 173                 defenders: unit.defenders * amount,
 174                 gold: unit.gold * amount,
 175                 bushels: unit.bushels * amount
 176         });
 177 });
 178
 179 server.post<{
 180         body: {
 181                 amount: string,
 182                 building_type: string,
 183         }
 184 }, void>('/build', async req => {
 185         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 186         const city = await cityRepo.getUsersCity(account.id);
 187
 188         const amount = parseInt(req.body.amount, 10);
 189         const building = await cityRepo.buildingRepository.findBySlug(req.body.building_type);
 190
 191         if(!building) {
 192                 throw new NotFoundError(`Invalid building type ${req.body.building_type}`, ERROR_CODE.INVALID_BUILDING);
 193         }
 194
 195         const queueData = await cityRepo.buildBuilding(building, amount ,city);
 196
 197         construction.trigger(queueData, { delay: queueData.due });
 198 }, 'reload-construction-queue');
 199
 200 server.post<{
 201                 body: {
 202                         amount: string,
 203                         type: string
 204                 }
 205         },
 206         void
 207         >('/units', async req => {
 208         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 209         const city = await cityRepo.getUsersCity(acct.id);
 210
 211         const amount  = parseInt(req.body.amount, 10);
 212         const unit = await cityRepo.unitRepository.findBySlug(req.body.type);
 213
 214         if(!unit) {
 215                 throw new NotFoundError(`Invalid unit type ${req.body.type}`, ERROR_CODE.INVALID_UNIT);
 216         }
 217
 218         const queueData = await cityRepo.train(unit, amount, city);
 219         unitTraining.trigger(queueData, { delay: queueData.due });
 220
 221 }, 'reload-unit-training');
 222
 223 server.post<{
 224         body: {
 225                 city: string,
 226                 soldiers: string,
 227                 attackers: string,
 228                 defenders: string,
 229                 sp_attackers: string,
 230                 sp_defenders: string
 231         }
 232         },
 233         void
 234         >('/attack', async req => {
 235                 const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 236                 const city = await cityRepo.getUsersCity(acct.id);
 237                 const attackedCity = await cityRepo.FindOne({id: req.body.city});
 238
 239                 const army = {
 240                         soldiers: parseInt(req.body.soldiers),
 241                         attackers: parseInt(req.body.attackers),
 242                         defenders: parseInt(req.body.defenders),
 243                         sp_attackers: parseInt(req.body.sp_attackers),
 244                         sp_defenders: parseInt(req.body.sp_defenders)
 245                 };
 246
 247                 const armyQueue = await cityRepo.attack(city, attackedCity, army);
 248
 249                 fight.trigger(armyQueue, {
 250                         delay: armyQueue.due - Date.now()
 251                 });
 252         }, 'reload-outgoing-attacks');
 253
 254 server.get<void, string>('/messages', async req => {
 255         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 256         const msgs = await mailRepo.listReceivedMessages(acct.id);
 257
 258         return JSON.stringify(msgs);
 259 });
 260
 261 server.get<{params: {id: string}}, string>('/messages/:id', async req => {
 262         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 263         const msg = await mailRepo.getMessage(req.params.id, acct.id);
 264
 265         if(!msg) {
 266                 throw new NotFoundError('No such message', ERROR_CODE.DUPLICATE_CACHE_KEY);
 267         }
 268
 269         await mailRepo.markAsRead(msg.id, msg.to_account);
 270
 271         return renderMessage(msg);
 272 });
 273
 274 server.get<void, string>('/attacks/outgoing', async req => {
 275         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 276         const city = await cityRepo.getUsersCity(acct.id);
 277         const attacks = await cityRepo.armyRepository.listOutgoing(city.id);
 278
 279         return listOperations(attacks);
 280 });
 281
 282
 283 server.start();
 284
 285 tick.trigger({lastTickAt: 0, lastTick: 0});