12728621970

Committed 11 Jan 2025 11:55PM UTC coverage: 47.963% (-4.1%) from 52.086%

Build # 12728621970

Build Type

Pull #12

github

Committed by

web-flow

Commit Message

Merge e784abf9e into a8e301a23

Pull Request Pull Request #12: [fleets] Explore planets

Run Details

214 of 913 branches covered (23.44%)

Branch coverage included in aggregate %.

154 of 505 new or added lines in 55 files covered. (30.5%)

10 existing lines in 9 files now uncovered.

1564 of 2794 relevant lines covered (55.98%)

3.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.47

/packages/game-api-microservice/src/services/playerService.ts

import playerRepository from 'game-engine/dist/repositories/playerRepository'
import taskRepository from 'game-engine/dist/repositories/taskRepository'
import raceRepository from 'game-engine/dist/repositories/raceRepository'
import universeRepository from 'game-engine/dist/repositories/universeRepository'
import playerUnitsRepository from 'game-engine/dist/repositories/playerUnitsRepository'
import fleetRepository from 'game-engine/dist/repositories/fleetRepository'
import { ITask } from 'game-engine/dist/types/ITask'
import NotFoundError from 'auth-microservice/dist/errors/NotFoundError'
import ConflictError from 'auth-microservice/dist/errors/ConflictError'

import { PlayerData, createPlayerResponseType, getPlayerResponseType } from '../types/Player'
import { NewPlayerTaskType, NEW_PLAYER_TASK_TYPE, PENDING_TASK_STATUS } from '../types/Task'
import cleanTaskFields from '../utils/cleanTaskFields'
import cleanPlayerFields from '../utils/cleanPlayerFields'

async function createPlayer({
  username,
  email,
  isActivated,
  raceName,
  universeName
}: PlayerData): Promise<createPlayerResponseType> {
  if (!isActivated) {
    throw new ConflictError('user is not activated', { username })
  }

  const raceData = await raceRepository.findRaceByName(raceName)

  if (!raceData) {
    throw new NotFoundError('invalid race', { raceName })
  }

  const universe = await universeRepository.findUniverseByName(universeName)

  if (!universe) {
    throw new NotFoundError('invalid universe', { universeName })
  }

  const universeId = universe._id.toString()

  const player = await playerRepository.findPlayerByUsername(username, universeId)
  const duplicatedPlayerTask = await taskRepository.findNewPlayerTaskByUsername(
    username,
    universe._id
  )

  if (player || duplicatedPlayerTask) {
    throw new ConflictError('player already created', { username })
  }

  const newPlayerTask: ITask<NewPlayerTaskType> = {
    type: NEW_PLAYER_TASK_TYPE,
    universeId,

    data: {
      username,
      email,
      raceId: raceData._id.toString()
    },

    status: PENDING_TASK_STATUS,
    isCancellable: false,

    executeTaskAt: null,
    processedAt: null,
    processingDuration: null,

    history: [
      {
        taskStatus: PENDING_TASK_STATUS,
        updatedAt: new Date().getTime()
      }
    ],

    errorDetails: null
  }

  const task = await taskRepository.createPlayerTask(newPlayerTask)

  return { task: cleanTaskFields(task) }
}

async function getPlayer(username: string, universeName: string): Promise<getPlayerResponseType> {
  const universe = await universeRepository.findUniverseByName(universeName)

  if (!universe) {
    throw new NotFoundError('invalid universe', { universeName })
  }

  const universeId = universe._id.toString()

  const player = await playerRepository.findPlayerByUsername(username, universeId)

  if (!player) {
    // TODO: create enum or const for the errors NO_PLAYER_FOUND_ERROR
    throw new NotFoundError('no player present in this universe', { username, universeName })
  }

  // TODO: add future pending tasks to tack them in the frontend

  const fleets = await fleetRepository.findFleetsByPlayerId(player._id.toString())
  const playerUnits = await playerUnitsRepository.findPlayerUnits(player._id.toString())

  return { player: cleanPlayerFields(player, fleets, playerUnits) }
}

const playerService = {
  createPlayer,
  getPlayer
}

export default playerService

1	import playerRepository from 'game-engine/dist/repositories/playerRepository'	2✔
2	import taskRepository from 'game-engine/dist/repositories/taskRepository'	2✔
3	import raceRepository from 'game-engine/dist/repositories/raceRepository'	2✔
4	import universeRepository from 'game-engine/dist/repositories/universeRepository'	2✔
5	import playerUnitsRepository from 'game-engine/dist/repositories/playerUnitsRepository'	2✔
6	import fleetRepository from 'game-engine/dist/repositories/fleetRepository'	2✔
7	import { ITask } from 'game-engine/dist/types/ITask'
8	import NotFoundError from 'auth-microservice/dist/errors/NotFoundError'	2✔
9	import ConflictError from 'auth-microservice/dist/errors/ConflictError'	2✔
10
11	import { PlayerData, createPlayerResponseType, getPlayerResponseType } from '../types/Player'
12	import { NewPlayerTaskType, NEW_PLAYER_TASK_TYPE, PENDING_TASK_STATUS } from '../types/Task'	2✔
13	import cleanTaskFields from '../utils/cleanTaskFields'	2✔
14	import cleanPlayerFields from '../utils/cleanPlayerFields'	2✔
15
16	async function createPlayer({
17	username,
18	email,
19	isActivated,
20	raceName,
21	universeName
22	}: PlayerData): Promise<createPlayerResponseType> {
23	if (!isActivated) {	7✔
24	throw new ConflictError('user is not activated', { username })	1✔
25	}
26
27	const raceData = await raceRepository.findRaceByName(raceName)	6✔
28
29	if (!raceData) {	6✔
30	throw new NotFoundError('invalid race', { raceName })	1✔
31	}
32
33	const universe = await universeRepository.findUniverseByName(universeName)	5✔
34
35	if (!universe) {	5✔
36	throw new NotFoundError('invalid universe', { universeName })	1✔
37	}
38
39	const universeId = universe._id.toString()	4✔
40
41	const player = await playerRepository.findPlayerByUsername(username, universeId)	4✔
42	const duplicatedPlayerTask = await taskRepository.findNewPlayerTaskByUsername(	4✔
43	username,
44	universe._id
45	)
46
47	if (player \|\| duplicatedPlayerTask) {	4✔
48	throw new ConflictError('player already created', { username })	2✔
49	}
50
51	const newPlayerTask: ITask<NewPlayerTaskType> = {	2✔
52	type: NEW_PLAYER_TASK_TYPE,
53	universeId,
54
55	data: {
56	username,
57	email,
58	raceId: raceData._id.toString()
59	},
60
61	status: PENDING_TASK_STATUS,
62	isCancellable: false,
63
64	executeTaskAt: null,
65	processedAt: null,
66	processingDuration: null,
67
68	history: [
69	{
70	taskStatus: PENDING_TASK_STATUS,
71	updatedAt: new Date().getTime()
72	}
73	],
74
75	errorDetails: null
76	}
77
78	const task = await taskRepository.createPlayerTask(newPlayerTask)	2✔
79
80	return { task: cleanTaskFields(task) }	2✔
81	}
82
83	async function getPlayer(username: string, universeName: string): Promise<getPlayerResponseType> {
84	const universe = await universeRepository.findUniverseByName(universeName)	×
85
86	if (!universe) {	×
87	throw new NotFoundError('invalid universe', { universeName })	×
88	}
89
90	const universeId = universe._id.toString()	×
91
92	const player = await playerRepository.findPlayerByUsername(username, universeId)	×
93
94	if (!player) {	×
95	// TODO: create enum or const for the errors NO_PLAYER_FOUND_ERROR
96	throw new NotFoundError('no player present in this universe', { username, universeName })	×
97	}
98
99	// TODO: add future pending tasks to tack them in the frontend
100
NEW 101	const fleets = await fleetRepository.findFleetsByPlayerId(player._id.toString())	×
NEW 102	const playerUnits = await playerUnitsRepository.findPlayerUnits(player._id.toString())	×
103
NEW 104	return { player: cleanPlayerFields(player, fleets, playerUnits) }	×
105	}
106
107	const playerService = {	2✔
108	createPlayer,
109	getPlayer
110	}
111
112	export default playerService	2✔

DaniSomoza / galactic-commander / 12728621970

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous