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 `<div class="alert success">You are all signed up! You can go ahead and log in</div>`;
  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.getUsersCity(account.id);
  83         const city = await cityRepo.findById(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.getUsersCity(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.getUsersCity(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.getUsersCity(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.getUsersCity(account.id);
 123
 124         return renderOverworldMap(await cityRepo.findAllInSector(city.sector_id), 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.trim(), 10);
 141         console.log('checking amount', amount);
 142
 143         if(isNaN(amount) || amount < 1) {
 144                 return '';
 145         }
 146         const building = await cityRepo.buildingRepository.findBySlug(req.body.building_type);
 147
 148         if(!building) {
 149                 throw new NotFoundError(`Invalid building type ${req.body.building_type}`, ERROR_CODE.INVALID_BUILDING);
 150         }
 151
 152         return JSON.stringify({
 153                 gold: building.gold * amount,
 154                 ore: building.ore * amount,
 155                 logs: building.logs * amount,
 156                 land: building.land * amount,
 157                 time: building.time
 158         });
 159 });
 160
 161 server.post<{
 162         body: {
 163                 amount: string;
 164                 type: string;
 165         }
 166 }, string>('/cost/training', async req => {
 167         const amount = parseInt(req.body.amount, 10);
 168         const unit = await cityRepo.unitRepository.findBySlug(req.body.type);
 169
 170         if(!unit) {
 171                 throw new NotFoundError(`Invalid unit type ${req.body.type}`, ERROR_CODE.INVALID_UNIT);
 172         }
 173
 174         return JSON.stringify({
 175                 population: unit.population * amount,
 176                 soldiers: unit.soldiers * amount,
 177                 attackers: unit.attackers * amount,
 178                 defenders: unit.defenders * amount,
 179                 gold: unit.gold * amount,
 180                 bushels: unit.bushels * amount
 181         });
 182 });
 183
 184 server.post<{
 185         body: {
 186                 amount: string,
 187                 building_type: string,
 188         }
 189 }, void>('/build', async req => {
 190         const account = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 191         const city = await cityRepo.getUsersCity(account.id);
 192
 193         const amount = parseInt(req.body.amount, 10);
 194         const building = await cityRepo.buildingRepository.findBySlug(req.body.building_type);
 195
 196         if(!building) {
 197                 throw new NotFoundError(`Invalid building type ${req.body.building_type}`, ERROR_CODE.INVALID_BUILDING);
 198         }
 199
 200         const queueData = await cityRepo.buildBuilding(building, amount ,city);
 201
 202         construction.trigger(queueData, { delay: queueData.due });
 203 }, 'reload-construction-queue');
 204
 205 server.post<{
 206                 body: {
 207                         amount: string,
 208                         type: string
 209                 }
 210         },
 211         void
 212         >('/units', async req => {
 213         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 214         const city = await cityRepo.getUsersCity(acct.id);
 215
 216         const amount  = parseInt(req.body.amount, 10);
 217         const unit = await cityRepo.unitRepository.findBySlug(req.body.type);
 218
 219         if(!unit) {
 220                 throw new NotFoundError(`Invalid unit type ${req.body.type}`, ERROR_CODE.INVALID_UNIT);
 221         }
 222
 223         const queueData = await cityRepo.train(unit, amount, city);
 224         unitTraining.trigger(queueData, { delay: queueData.due });
 225
 226 }, 'reload-unit-training');
 227
 228 server.post<{
 229         body: {
 230                 city: string,
 231                 soldiers: string,
 232                 attackers: string,
 233                 defenders: string,
 234                 sp_attackers: string,
 235                 sp_defenders: string
 236         }
 237         },
 238         void
 239         >('/attack', async req => {
 240                 const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 241                 const city = await cityRepo.getUsersCity(acct.id);
 242                 const attackedCity = await cityRepo.findById(req.body.city);
 243
 244                 const army = {
 245                         soldiers: parseInt(req.body.soldiers),
 246                         attackers: parseInt(req.body.attackers),
 247                         defenders: parseInt(req.body.defenders),
 248                         sp_attackers: parseInt(req.body.sp_attackers),
 249                         sp_defenders: parseInt(req.body.sp_defenders)
 250                 };
 251
 252                 const armyQueue = await cityRepo.attack(city, attackedCity, army);
 253
 254                 fight.trigger(armyQueue, {
 255                         delay: armyQueue.due - Date.now()
 256                 });
 257         }, 'reload-outgoing-attacks');
 258
 259 server.get<void, string>('/messages', async req => {
 260         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 261         const msgs = await mailRepo.listReceivedMessages(acct.id);
 262
 263         return JSON.stringify(msgs);
 264 });
 265
 266 server.get<{params: {id: string}}, string>('/messages/:id', async req => {
 267         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 268         const msg = await mailRepo.getMessage(req.params.id, acct.id);
 269
 270         if(!msg) {
 271                 throw new NotFoundError('No such message', ERROR_CODE.DUPLICATE_CACHE_KEY);
 272         }
 273
 274         await mailRepo.markAsRead(msg.id, msg.to_account);
 275
 276         return renderMessage(msg);
 277 });
 278
 279 server.get<void, string>('/attacks/outgoing', async req => {
 280         const acct = await accountRepo.validate(req.authInfo.accountId, req.authInfo.token);
 281         const city = await cityRepo.getUsersCity(acct.id);
 282         const attacks = await cityRepo.armyRepository.listOutgoing(city.id);
 283
 284         return listOperations(attacks);
 285 });
 286
 287
 288 server.start();