cloud/tcc-vamos-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajustes

Browse Source
This commit is contained in:
Hugo Falcao
2022-04-17 20:50:42 -03:00
parent 24c072f750
commit c4917d248f
11 changed files with 4 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
src/routes/follows.routes.ts
View File

@@ -1,90 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import Follow from '../models/Follow';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import CreateFollowService from '../services/CreateFollowService';
import DeleteFollowService from '../services/DeleteFollowService';
import CheckUserIsFollowingUserService from '../services/CheckUserIsFollowingUserService';
import UpdateFollowCounterService from '../services/UpdateFollowCounterService';
import FindUserFollowersService from '../services/FindUserFollowersService';
const followsRouter = Router();
followsRouter.get('/list', ensureAuthenticated, async (request, response) => {
const followsRepository = getRepository(Follow);
const follows = await followsRepository.find();
return response.json({ data: follows });
});
followsRouter.get('/get/:id', ensureAuthenticated, async (request, response) => {
const { id } = request.params;
const findUserFollowersService = new FindUserFollowersService();
const followers = await findUserFollowersService.execute(id);
return response.json({ data: followers });
});
followsRouter.get(
'/check/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const checkUserIsFollowingUserService = new CheckUserIsFollowingUserService();
const checkUserIsFollowing = await checkUserIsFollowingUserService.execute({
id_user_following: request.user.id_user,
id_user_followed: id,
});
return response.json({ data: checkUserIsFollowing });
},
);
followsRouter.post('/add', ensureAuthenticated, async (request, response) => {
const { id_user_followed } = request.body;
const createFollowService = new CreateFollowService();
// TODO, necessário?
await createFollowService.execute({
id_user_following: request.user.id_user,
id_user_followed,
});
const updateFollowCounterService = new UpdateFollowCounterService();
await updateFollowCounterService.execute({ id_user: id_user_followed });
return response.json({ message: 'User followed succesfully. ' });
});
followsRouter.delete(
'/remove/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const deleteFollowService = new DeleteFollowService();
await deleteFollowService.execute({
id_user_following: request.user.id_user,
id_user_followed: id,
});
const updateFollowCounterService = new UpdateFollowCounterService();
await updateFollowCounterService.execute({ id_user: id });
return response.json({ message: 'Unfollowed user.' });
},
);
export default followsRouter;

14
src/routes/index.ts
View File

@@ -2,24 +2,10 @@ import { Router } from 'express';
import sessionsRouter from './sessions.routes';
import usersRouter from './users.routes';
import tournamentsRouter from './tournaments.routes';
import pubsRouter from './publications.routes';
import tournamentParticipantsRouter from './tournamentParticipants.routes';
import tournamentColumnsRouter from './tournamentColumns.routes';
import followsRouter from './follows.routes';
import itemRouter from './item.routes';
import inventarioRouter from './inventario.routes';
const routes = Router();
routes.use('/users', usersRouter);
routes.use('/sessions', sessionsRouter);
routes.use('/tournaments', tournamentsRouter);
routes.use('/tournaments/manage', tournamentParticipantsRouter);
routes.use('/tournaments/columns', tournamentColumnsRouter);
routes.use('/pubs', pubsRouter);
routes.use('/follows/', followsRouter);
routes.use('/item/', itemRouter);
routes.use('/inventario/', inventarioRouter);
export default routes;

75
src/routes/inventario.routes.ts
View File

@@ -1,75 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import Inventario from '../models/Inventario';
import AddItemService from '../services/AddItemService';
import FindInventarioUser from '../services/FindInventarioUserService';
import FindItensAtivosService from '../services/FindItensAtivosService';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import UpdateAtivaItemService from '../services/UpdateAtivaItemService';
import UpdateDesativaItemService from '../services/UpdateDesativaItemService';
const inventarioRouter = Router();
inventarioRouter.get('/', ensureAuthenticated, async (request, response) => {
const inventarioRepository = getRepository(Inventario);
const inventario = await inventarioRepository.find();
return response.json({ data: inventario });
});
inventarioRouter.get('/find', ensureAuthenticated, async (request, response) => {
const findInventarioUser = new FindInventarioUser;
const inventario = await findInventarioUser.execute( request.user.id_user );
return response.json({ data: inventario });
});
inventarioRouter.get('/findativos', ensureAuthenticated, async (request, response) => {
const findItensAtivosService = new FindItensAtivosService;
const inventario = await findItensAtivosService.execute( request.user.id_user );
return response.json({ data: inventario });
});
inventarioRouter.post('/', ensureAuthenticated, async (request, response) => {
const { id_item } = request.body;
const addItem = new AddItemService();
await addItem.execute({ id_item, id_user: request.user.id_user});
return response.json({ message: 'Item adicionado com sucesso !' });
});
inventarioRouter.patch('/edit/ativa', ensureAuthenticated, async (request, response) => {
const { id_item } = request.body;
const updateInventarioService = new UpdateAtivaItemService();
await updateInventarioService.execute({
id_user: request.user.id_user,
id_item
});
return response.json({ message: 'Item ativado com sucesso !' });
});
inventarioRouter.patch('/edit/desativa', ensureAuthenticated, async (request, response) => {
const { id_item } = request.body;
const updateDesativaItemService = new UpdateDesativaItemService();
await updateDesativaItemService.execute({
id_user: request.user.id_user,
id_item
});
return response.json({ message: 'Item desativado com sucesso !' });
});
export default inventarioRouter;

46
src/routes/item.routes.ts
View File

@@ -1,46 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import Item from '../models/Item';
import CreateItemService from '../services/CreateItemService';
const itemRouter = Router();
itemRouter.get('/', async (request, response) => {
const itemsRepository = getRepository(Item);
const items = await itemsRepository.find();
return response.json({ data: items });
});
itemRouter.post('/', async (request, response) => {
const { nome, tipo, asset, preco } = request.body;
const createItemService = new CreateItemService();
createItemService.execute({ nome, tipo, asset, preco });
return response.json({ message: 'Item criado com sucesso !!!'});
});
// itemRouter.patch('/edit', ensureAuthenticated, async (request, response) => {
// const { name, itemname, bio, email, birth_date } = request.body;
// const updateitemService = new UpdateitemService();
// await updateitemService.execute({
// id_item: request.item.id_item,
// name,
// itemname,
// bio,
// email,
// birth_date,
// });
// return response.json({ message: 'item info sucessfully updated.' });
// });
export default itemRouter;

38
src/routes/publications.routes.ts
View File

@@ -1,38 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import Publication from '../models/Publication';
import CreatePublicationService from '../services/CreatePublicationService';
import FindTournamentsPublicatedService from '../services/FindTournamentsPublicatedService';
const pubsRouter = Router();
pubsRouter.get('/', async (request, response) => {
const publicationsRepository = getRepository(Publication);
const publications = await publicationsRepository.find();
return response.json({ data: publications });
});
pubsRouter.post('/', ensureAuthenticated, async (request, response) => {
const { id_tournament } = request.body;
const createPublicationService = new CreatePublicationService();
createPublicationService.execute({ id_user: request.user.id_user, id_tournament });
return response.json({ message: "Publicação criada com sucesso !!!" })
});
pubsRouter.get('/find', ensureAuthenticated, async (request, response) => {
const findPublicationService = new FindTournamentsPublicatedService();
const publications = await findPublicationService.execute( request.user.id_user );
return response.json({ data: publications });
});
export default pubsRouter;

77
src/routes/tournamentColumns.routes.ts
View File

@@ -1,77 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import TournamentColumns from '../models/TournamentColumns';
import FindTournamentColumnsService from '../services/FindTournamentColumnsService';
import UpdateTournamentColumnsInitializedFlagService from '../services/UpdateTournamentColumnsInitializedFlagService';
import UpdateTournamentColumnsService from '../services/UpdateTournamentColumnsService';
const tournamentColumnsRouter = Router();
// não deve ser lançado
tournamentColumnsRouter.get('/list', async (request, response) => {
const tournamentsColumnsRepository = getRepository(TournamentColumns);
const tournamentsColumns = await tournamentsColumnsRepository.find();
return response.json({ data: tournamentsColumns });
});
// colunas de um torneio específico
tournamentColumnsRouter.get(
'/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const findTournamentColumnsService = new FindTournamentColumnsService();
const tournamentColumns = await findTournamentColumnsService.execute(id);
return response.json({ data: tournamentColumns });
},
);
// atualiza as colunas
tournamentColumnsRouter.patch(
'/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const { column1, column2, column3, column4 } = request.body;
const updateTournamentColumnsService = new UpdateTournamentColumnsService();
await updateTournamentColumnsService.execute(id, {
column1,
column2,
column3,
column4,
});
return response.json({
message: 'Tournament columns updated sucessfully.',
});
},
);
// atualiza a flag da coluna tournament_initialized
tournamentColumnsRouter.patch(
'/flag/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const { flag } = request.body;
const updateTournamentColumnsInitializedFlagService = new UpdateTournamentColumnsInitializedFlagService();
await updateTournamentColumnsInitializedFlagService.execute(id, flag);
return response.json({
message: 'Tournament columns flag updated sucessfully.',
});
},
);
export default tournamentColumnsRouter;

203
src/routes/tournamentParticipants.routes.ts
View File

@@ -1,203 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import TournamentParticipants from '../models/TournamentParticipant';
import CheckUserIsKickedFromTournamentService from '../services/CheckUserIsKickedFromTournamentService';
import CreateTournamentParticipantService from '../services/CreateTournamentParticipantService';
import FindAcceptedTournamentParticipantsService from '../services/FindAcceptedTournamentParticipantsService';
import FindKickedParticipantsFromTournamentService from '../services/FindKickedParticipantsFromTournamentService';
import FindPendingTournamentInvitesService from '../services/FindPendingTournamentInvitesService';
import FindTournamentsUserIsParticipatingService from '../services/FindTournamentsUserIsParticipatingService';
import KickTournamentParticipantService from '../services/KickTournamentParticipantService';
import UpdateTournamentsInviteUserAcceptedService from '../services/UpdateTournamentsInviteUserAcceptedService';
import UpdateTournamentsInviteUserRefusedService from '../services/UpdateTournamentsInviteUserRefusedService';
const tournamentParticipantsRouter = Router();
// observação:
// essa rota trata da tabela tournamentParticipants
// que vai cuidar da parte tanto do convite da pessoa tanto de sua participação
// pela coluna user_accepted_invite
// não deve ser lançado
tournamentParticipantsRouter.get('/list', async (request, response) => {
const tournamentsParticipantsRepository = getRepository(
TournamentParticipants,
);
const tournamentsParticipants = await tournamentsParticipantsRepository.find();
return response.json({ data: tournamentsParticipants });
});
// rota que vai retornar os tournamentInvites de outra pessoa
// interessante para mostrar os torneios públicos em que a pessoa está participando, isso do perfil dela
// mas não é o foco da sprint atual (2)
/*
tournamentParticipantsRouter.get('/user/:id', ensureAuthenticated, async (request, response) => {
let { id } = request.params;
const findTournamentService = new FindTournamentService();
const tournament = await findTournamentService.execute(id);
return response.json({ data: tournament });
});
*/
// rota que vai retornar os tournamentInvites (com os torneios que o usuário logado está participando)
tournamentParticipantsRouter.get(
'/user',
ensureAuthenticated,
async (request, response) => {
const findTournamentsUserIsParticipatingService = new FindTournamentsUserIsParticipatingService();
const tournamentsUserIsParticipating = await findTournamentsUserIsParticipatingService.execute(
request.user.id_user,
);
return response.json({ data: tournamentsUserIsParticipating });
},
);
// pega os participantes (Users) de um torneio e retorna apenas aqueles que aceitaram (user_accepted_invite -> true)
tournamentParticipantsRouter.get(
'/users/accepted/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const findAcceptedTournamentParticipantsService = new FindAcceptedTournamentParticipantsService();
const tournamentAcceptedParticipantsAsUsers = await findAcceptedTournamentParticipantsService.execute(
id,
);
return response.json({ data: tournamentAcceptedParticipantsAsUsers });
},
);
// pega os invites pendentes de um usuário
tournamentParticipantsRouter.get(
'/user/pending/',
ensureAuthenticated,
async (request, response) => {
const findPendingTournamentInvitesService = new FindPendingTournamentInvitesService();
const pendingInvites = await findPendingTournamentInvitesService.execute(
request.user.id_user,
);
return response.json({ data: pendingInvites });
},
);
// cria um convite
tournamentParticipantsRouter.post(
'/invite/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const { id_tournament } = request.body;
const createTournamentParticipantService = new CreateTournamentParticipantService();
await createTournamentParticipantService.execute({
id_user: id,
id_tournament,
creator_id_user: request.user.id_user,
});
return response.json({ message: 'Invitation created sucessfully.' });
},
);
// aceita um convite de um torneio
tournamentParticipantsRouter.patch(
'/accept/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const updateTournamentsInviteUserAcceptedService = new UpdateTournamentsInviteUserAcceptedService();
await updateTournamentsInviteUserAcceptedService.execute({
id_tournament: id,
id_user: request.user.id_user,
});
return response.json({ message: 'Invitation accepted.' });
},
);
// recusa um convite de um torneio
tournamentParticipantsRouter.patch(
'/refuse/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const updateTournamentsInviteUserRefusedService = new UpdateTournamentsInviteUserRefusedService();
await updateTournamentsInviteUserRefusedService.execute({
id_tournament: id,
id_user: request.user.id_user,
});
return response.json({ message: 'Invitation accepted.' });
},
);
tournamentParticipantsRouter.patch(
'/kick',
ensureAuthenticated,
async (request, response) => {
const { id_user, id_tournament } = request.body;
const kickTournamentParticipantService = new KickTournamentParticipantService();
await kickTournamentParticipantService.execute({
id_user,
id_tournament,
});
return response.json({ message: 'User was kicked from tournament.' });
},
);
// TODO, não devia ser post
tournamentParticipantsRouter.post(
'/iskicked',
ensureAuthenticated,
async (request, response) => {
const { id_user, id_tournament } = request.body;
const checkUserIsKickedFromTournamentService = new CheckUserIsKickedFromTournamentService();
const isUserKicked = await checkUserIsKickedFromTournamentService.execute({
id_user,
id_tournament,
});
return response.json({ message: isUserKicked });
},
);
// retorna um array de users que foram kickados de um torneio
tournamentParticipantsRouter.get(
'/kicked/:id',
ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const findKickedParticipantsFromTournamentService = new FindKickedParticipantsFromTournamentService();
const tournamentKickedUsers = await findKickedParticipantsFromTournamentService.execute(
id,
);
return response.json({ data: tournamentKickedUsers });
},
);
export default tournamentParticipantsRouter;

96
src/routes/tournaments.routes.ts
View File

@@ -1,96 +0,0 @@
// TODO: Arrumar a rota
import { Router } from 'express';
import { getRepository } from 'typeorm';
import { v4 } from 'uuid';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import Tournament from '../models/Tournament';
import CreateTournamentService from '../services/CreateTournamentService';
import FindTournamentsByUserService from '../services/FindTournamentsByUserService';
import FindTournamentService from '../services/FindTournamentService';
import UpdateTournamentAsEndedService from '../services/UpdateTournamentAsEnded';
import UpdateTournamentService from '../services/UpdateTournamentService';
const tournamentsRouter = Router();
// não deve ser lançado
tournamentsRouter.get('/list', async (request, response) => {
const tournamentsRepository = getRepository(Tournament);
const tournaments = await tournamentsRepository.find();
return response.json({ data: tournaments });
});
tournamentsRouter.get(
'/id/:id',
ensureAuthenticated,
async (request, response) => {
let { id } = request.params;
const findTournamentService = new FindTournamentService();
const tournament = await findTournamentService.execute(id);
return response.json({ data: tournament });
},
);
tournamentsRouter.get(
'/user',
ensureAuthenticated,
async (request, response) => {
const findTournamentByUserService = new FindTournamentsByUserService();
const tournaments = await findTournamentByUserService.execute(
request.user.id_user,
);
return response.json({ data: tournaments });
},
);
tournamentsRouter.post('/', ensureAuthenticated, async (request, response) => {
const {
name,
game,
description,
password,
number_participants,
} = request.body;
const createTournamentService = new CreateTournamentService();
createTournamentService.execute({
id_user: request.user.id_user,
name,
game,
description,
password,
number_participants,
});
return response.json({ message: 'Tournament created sucessfully.' });
});
tournamentsRouter.patch('/edit/:id', async (request, response) => {
const { id } = request.params;
const { name, game, description, password } = request.body;
const updateTournamentService = new UpdateTournamentService();
updateTournamentService.execute({ id, name, game, description, password });
return response.json({ message: 'Tournament updated sucessfully.' });
});
tournamentsRouter.patch('/end/:id', async (request, response) => {
const { id } = request.params;
const updateTournamentAsEndedService = new UpdateTournamentAsEndedService();
await updateTournamentAsEndedService.execute({ id_tournament: id });
return response.json({ message: 'Tournament was set as ended.' });
});
export default tournamentsRouter;

69
src/routes/users.routes.ts
View File

@@ -8,13 +8,10 @@ import FindUserSocialService from '../services/FindUserSocialService';
import UpdateUserSocialService from '../services/UpdateUserSocialService';
import UpdateUserService from '../services/UpdateUserService';
import UpdateUserAvatarService from '../services/UpdateUserAvatarService';
import UpdateUserBackgroundService from '../services/UpdateUserBackgroundService';
import UpdateUserPasswordService from '../services/UpdateUserPasswordService';
import ensureAuthenticated from '../middlewares/ensureAuthenticated';
import ensureAdmin from '../middlewares/ensureAdmin';
import AuthenticateUserService from '../services/AuthenticateUserService';
import UpdateUserCoinsService from '../services/UpdateUserCoinsService';
import FindUserColocationsService from '../services/FindUserColocationsService';
const usersRouter = Router();
@@ -119,19 +116,6 @@ usersRouter.patch('/edit/avatar', ensureAuthenticated, async (request, response)
return response.json({ message: 'Avatar atualizado com sucesso !' });
});
usersRouter.patch('/edit/background', ensureAuthenticated, async (request, response) => {
const { background_image } = request.body;
const updateUserBackgroundService = new UpdateUserBackgroundService();
await updateUserBackgroundService.execute({
id_user: request.user.id_user,
background_image,
});
return response.json({ message: 'Background atualizado com sucesso !' });
});
usersRouter.get(
'/social/:id',
ensureAuthenticated,
@@ -157,7 +141,6 @@ usersRouter.patch(
await updateUserSocialService.execute({
id_user: request.user.id_user,
social_network,
username,
});
return response.json({ message: 'Social info sucessfully updated.' });
@@ -182,56 +165,4 @@ usersRouter.patch(
},
);
usersRouter.patch(
'/coins/add',
ensureAuthenticated,
async (request, response) => {
const { id_user, quantity } = request.body;
const updateUserCoins = new UpdateUserCoinsService();
await updateUserCoins.execute({
id_user,
quantity,
operation: 'add',
});
return response.json({ message: quantity + ' coins were given.' });
},
);
usersRouter.patch(
'/coins/remove',
ensureAuthenticated,
async (request, response) => {
const { id_user, quantity } = request.body;
const updateUserCoins = new UpdateUserCoinsService();
await updateUserCoins.execute({
id_user,
quantity,
operation: 'remove',
});
return response.json({ message: quantity + ' coins were taken.' });
},
);
// vai retornar as colocações de um usuário
usersRouter.get(
'/colocations/:id',
// TODO, voltar
// ensureAuthenticated,
async (request, response) => {
const { id } = request.params;
const findUserColocationsService = new FindUserColocationsService();
const userColocations = await findUserColocationsService.execute(id);
return response.json({ data: userColocations });
},
);
export default usersRouter;

1
src/services/UpdateUserService.ts
View File

@@ -28,7 +28,6 @@ class UpdateUserService {
};
user.name = name;
user.username = username;
user.bio = bio;
user.birth_date = new Date(birth_date); // TODO, funciona?

10
src/services/UpdateUserSocialService.ts
View File

@@ -8,14 +8,12 @@ import Social from '../models/Social';
interface Request {
id_user: string;
social_network: string;
username: string;
}
class UpdateUserSocialService {
public async execute({
id_user,
social_network,
username,
}: Request): Promise<Social> {
const usersRepository = getRepository(User);
const socialRepository = getRepository(Social);
@@ -36,16 +34,16 @@ class UpdateUserSocialService {
switch (social_network) {
case 'telegram':
social.telegram = username;
social.telegram = "";
break;
case 'facebook':
social.facebook = username;
social.facebook = "";
break;
case 'twitter':
social.twitter = username;
social.twitter = "";
break;
case 'twitch':
social.twitch = username;
social.twitch = "";
break;
default: