Create user

src/routes/follows.routes.ts

@@ -0,0 +1,90 @@
+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;

src/routes/index.ts

@@ -0,0 +1,25 @@
+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;

src/routes/inventario.routes.ts

@@ -0,0 +1,75 @@
+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;

src/routes/item.routes.ts

@@ -0,0 +1,46 @@
+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;

src/routes/publications.routes.ts

@@ -0,0 +1,38 @@
+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;

src/routes/sessions.routes.ts

@@ -0,0 +1,21 @@
+import { Router } from 'express';
+
+import AuthenticateUserService from '../services/AuthenticateUserService';
+
+const sessionsRouter = Router();
+
+// login pode ser: email ou username
+sessionsRouter.post('/', async (request, response) => {
+  const { login, password } = request.body;
+
+  const authenticateUserService = new AuthenticateUserService();
+
+  const token = await authenticateUserService.execute({
+    login,
+    password,
+  });
+
+  return response.json({ message: 'User logged in sucessfully', token: token });
+});
+
+export default sessionsRouter;

src/routes/tournamentColumns.routes.ts

@@ -0,0 +1,77 @@
+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;

src/routes/tournamentParticipants.routes.ts

@@ -0,0 +1,203 @@
+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;

src/routes/tournaments.routes.ts

@@ -0,0 +1,96 @@
+// 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;

src/routes/users.routes.ts

@@ -0,0 +1,237 @@
+import { Router } from 'express';
+import { getRepository } from 'typeorm';
+import User from '../models/User';
+
+import CreateUserService from '../services/CreateUserService';
+import FindUserService from '../services/FindUserService';
+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();
+
+interface userWithoutSensitiveInfo {
+  id_user: string;
+  name: string;
+  email: string;
+  avatar_image: string;
+}
+
+usersRouter.get('/list', async (request, response) => {
+  const usersRepository = getRepository(User);
+
+  const users = await usersRepository.find();
+
+  let usersWithoutSensitiveInfo: userWithoutSensitiveInfo[] = [];
+
+  users.map(user => {
+    usersWithoutSensitiveInfo.push({
+      id_user: user.id_user,
+      name: user.name,
+      email: user.email,
+      avatar_image: user.avatar_image,
+    });
+  });
+
+  return response.json({ data: usersWithoutSensitiveInfo });
+});
+
+// TODO, criar middleware ensureIsOwnUser é necessário?
+// usar browserAgent, Encrypted Local Storage ou algo do tipo
+usersRouter.get('/:id', ensureAuthenticated, async (request, response) => {
+  const { id } = request.params;
+
+  const findUser = new FindUserService();
+
+  const user = await findUser.execute(id);
+
+  const userWithoutPassword = {
+    id_user: user.id_user,
+    name: user.name,
+    email: user.email,
+    birth_date: user.birth_date,
+    avatar_image: user.avatar_image,
+    bio: user.bio,
+    created_at: user.created_at,
+    updated_at: user.updated_at,
+  };
+
+  return response.json({ data: userWithoutPassword });
+});
+
+usersRouter.post('/', async (request, response) => {
+  const { name, email, birth_date, password } = request.body;
+
+  const createUser = new CreateUserService();
+
+  const user = await createUser.execute({
+    name,
+    email,
+    birth_date,
+    password,
+  });
+
+  const authenticateUser = new AuthenticateUserService();
+
+  const token = await authenticateUser.execute({
+    login: user.email,
+    password: password,
+  });
+
+  return response.json({ message: 'User successfully created.', token: token });
+});
+
+usersRouter.patch('/edit', ensureAuthenticated, async (request, response) => {
+  const { name, username, bio, email, birth_date } = request.body;
+
+  const updateUserService = new UpdateUserService();
+
+  await updateUserService.execute({
+    id_user: request.user.id_user,
+    name,
+    username,
+    bio,
+    email,
+    birth_date,
+  });
+
+  return response.json({ message: 'User info sucessfully updated.' });
+});
+
+usersRouter.patch('/edit/avatar', ensureAuthenticated, async (request, response) => {
+  const { avatar_image } = request.body;
+
+  const updateUserAvatarService = new UpdateUserAvatarService();
+
+  await updateUserAvatarService.execute({
+    id_user: request.user.id_user,
+    avatar_image,
+  });
+
+  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,
+  async (request, response) => {
+    const { id } = request.params;
+
+    const findUserSocial = new FindUserSocialService();
+
+    const social = await findUserSocial.execute(id);
+
+    return response.json({ data: social });
+  },
+);
+
+usersRouter.patch(
+  '/edit/social',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { social_network, username } = request.body;
+
+    const updateUserSocialService = new UpdateUserSocialService();
+
+    await updateUserSocialService.execute({
+      id_user: request.user.id_user,
+      social_network,
+      username,
+    });
+
+    return response.json({ message: 'Social info sucessfully updated.' });
+  },
+);
+
+usersRouter.patch(
+  '/edit/password',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { password_old, password_new } = request.body;
+
+    const updateUserPasswordService = new UpdateUserPasswordService();
+
+    await updateUserPasswordService.execute({
+      id_user: request.user.id_user,
+      password_old: password_old,
+      password_new: password_new,
+    });
+
+    return response.json({ message: 'Password sucessfully updated.' });
+  },
+);
+
+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;