https://github.com/renatorosafranco/pokeapi-challenge
🚀 RAILS | API | pokeapi challenge ZRP
https://github.com/renatorosafranco/pokeapi-challenge
api challenge code-challenge pokemon-api rails-api ruby rubyonrails
Last synced: 7 days ago
JSON representation
🚀 RAILS | API | pokeapi challenge ZRP
- Host: GitHub
- URL: https://github.com/renatorosafranco/pokeapi-challenge
- Owner: RenatoRosaFranco
- Created: 2023-09-19T03:21:15.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2023-09-22T21:28:51.000Z (over 2 years ago)
- Last Synced: 2025-04-07T11:20:03.268Z (10 months ago)
- Topics: api, challenge, code-challenge, pokemon-api, rails-api, ruby, rubyonrails
- Language: Ruby
- Homepage:
- Size: 87.9 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# LEIA-ME
# ZRP Challenge
Challenge desenvolvido como teste de conhecimento da empresa ZRP, no cenário sugerido, foi proposto o desenvolvimento de um
end-point que consumirá uma API externa, assim trazendo so os dados interessantes a serem desenvolvidos em nossa api.
# TECNOLOGIAS
# ARQUITETURA
A arquitetura utilizada neste projeto consiste simplesmente em **4 Pilares principais**, O controller **(Pokemons)** responsavel por fazer a chamada
a API externa do **PokéAPI** através do interactor **FetchApiInteractor**, este interactor requisita o service de consulta a api externa chamado
de **PokemonServiceApi**, que retorna ao controller a resposta da requisição e em caso de sucesso renderiza o serializer **(PokemonSerializer)** como camada
de apresentação da estrutura da **response**, que apresenta apenas as **habilidades** do pokemon em um array ordenado por nome.
#### EXEMPLO:
Dada a chamada:
```
http://localhost:3000/api/v1/pokemons/:nome_pokemon
http://localhost:3000/api/v1/pokemons/charmander # exemplo
```
A Resposta da API devera ser
```
{
"abilities": [
"lightning-rod",
"static"
]
}
```
A Api devera devolver essa estrutura contendo as habilidades do pokemon, sendo mostradas por ordem alfabética
Abaixo uma lista para você realizar requisições para testar o endpoint com outros pokemons
| Pokemon |
|------------|
| ditto |
| venusaur |
| blastoise |
# IMAGENS
Abaixo você pode acompanhar uma Screenshot de uma requisição realizada ao endpoint com o pokemon **Pikachu**
### Pikachu
### Charmander
### Squirtle
### Não encontrado (Frodo)
# VERSÃO DO RUBY
Este projeto foi desenvolvido utilizando a **Versão** 3.0.0 do **Ruby**
```
3.2.0
```
# DEPENDENCIAS
Para instalar as dependencias do projeto, basta executar o comando abaixo em seu terminal na **pasta do projeto**.
```
bundle install
```
# CONFIGURAÇÕES
No arquivo **.env** na raiz de seu projeto coloque o seguinte valor
```
API_URL=https://pokeapi.co/api/
```
A Variavel de ambiente **API_URL** é necessária para termos o ponto base da URL que utilizaremos
da API do **PokéAPI** quando quisermos consultar os dados dos pokemons lá cadastrados, para montar
a nossa resposta.
Após adicionar a env basta subir o servidor utilizando o comando abaixo:
```
rails server -p 3000
```
# DOCKER
Você pode executar esse projeto através do docker, é simples e prático, basta executas os comandos abaixo
na pasta raiz do projeto, a mesma onde se encontram os arquivos **Dockerfile** e **docker-compose.yml**
```
docker-compose build --no-cache # make the build
docker-compose up # Initialize containers
docker-compose down # Remove containers
```
# TESTES
Você pode rodar os testes automatizados apartir da pasta raiz do projeto utilizando o comando abaixo.
```
bundle exec rspec /spec/interactors/
bundle exec rspec /spec/requests/
bundle exec rspec /spec/
```
# CACHING
A API tem um caching operando na endpoint /pokemons, onde o usuário so fara a requisição apenas uma vez
para um dado pokemon, sendo este resultado armazenado no Cache, se o usuário tentar requisitar informações
do mesmo pokemon novamente, a API não terá necessidade de realizar outra requisição, poderá utilizar os
dados da requisição prévia, já armazenada.
Módulo responsavel por implementar o cache na aplicação
```
# frozen_string_literal: true
module Http
module Cache
class CacheService
attr_reader :logger, :cache
def initialize(logger, cache)
@logger = logger
@cache = cache
end
def generate(suffix, name)
"#{suffix}_#{name}"
end
def read(cache_key)
logger.level = Logger::INFO
logger.write(:info, "Cache key #{cache_key} readed")
cache.read(cache_key)
rescue StandardError => e
logger.level = Logger::ERROR
logger.write(:error, "Failed to read cache key #{cache_key}")
end
def write(cache_key, serialized_object, expiration = 1.minute)
logger.level = Logger::INFO
logger.write(:info, "Cache Key create for #{cache_key}")
cache.write(cache_key, serialized_object, expires_in: expiration)
rescue StandardError => e
logger.level = Logger::ERROR
logger.write(:error, "Failed to write cache key #{cache_key}")
end
end
end
end
```
**OBS**: Para ver o cache em pleno funcionamento no ambiente de desenvolvimento basta executar o comando
abaixo antes de rodar o servidor:
```
bin/rails dev:cache # Development mode is now being cached.
```
Para desativar o Cache basta executar o comando novamente e o console irá te retornar o seguinte resultado:
```
bin/rails dev:cache # Development mode is no longer being cached.
```
