ChuckNorris

   1 package chucknorris.bitarus.allowed.org;
   2 
   3 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   4 import org.springframework.boot.SpringApplication;
   5 import org.springframework.context.annotation.ComponentScan;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 
   9 @ComponentScan //scans for @Component beans 
  10 @EnableAutoConfiguration
  11 public class Application {
  12     private static Logger logger;
  13 
  14     public static void main(String[] args) {
  15         logger = LoggerFactory.getLogger(Application.class);
  16         logger.info("Starting application");
  17         SpringApplication.run(Application.class, args);
  18     }
  19 }

   1 package chucknorris.bitarus.allowed.org;
   2 
   3 import org.springframework.stereotype.Controller;
   4 import org.springframework.web.bind.annotation.RequestMapping;
   5 import org.springframework.ui.Model;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 import org.springframework.web.bind.annotation.ResponseBody;
   9 
  10 import java.io.BufferedReader;
  11 import java.io.InputStreamReader;
  12 import java.io.OutputStream;
  13 import java.net.HttpURLConnection;
  14 import java.net.URL;
  15 import org.springframework.http.HttpMethod;
  16 import com.google.gson.Gson;
  17 import java.util.stream.Stream;
  18 import java.util.stream.Collectors;
  19 import java.util.List;
  20 import java.util.ArrayList;
  21 
  22 @Controller
  23 public class ChuckNorrisController{
  24     private final Logger logger = LoggerFactory.getLogger(ChuckNorrisController.class);
  25     
  26     public ChuckNorrisController(){
  27         logger.info("ChuckNorrisController created");
  28     }
  29 
  30     @RequestMapping("/chucknorris")
  31     @ResponseBody
  32     // http://localhost:8080/chucknorris
  33     public JokeResponse chucknorris() {
  34         String ret = "";
  35         Gson gson = new Gson();
  36 
  37         try {
  38             URL url = new URL("https://api.chucknorris.io/jokes/random");
  39             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  40             connection.connect();
  41             logger.info( Integer.toString(connection.getResponseCode() ));
  42 
  43             try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"))) {
  44                 StringBuilder response = new StringBuilder();
  45                 String responseLine = null;
  46                 while ((responseLine = br.readLine()) != null) {
  47                     response.append(responseLine.trim());
  48                 }
  49                 
  50                 Joke joke = gson.fromJson(response.toString(), Joke.class);
  51                 
  52 
  53                 List<Joke> jokesList = new ArrayList<Joke>();
  54                 jokesList.add(joke);
  55                 List<Joke> jokesList2 = jokesList.stream().map( item ->{item.setValue(item.getValue().toUpperCase()); return item;} ).collect(Collectors.toList());
  56                 joke = jokesList2.get(0);
  57                 ret = joke.getValue();
  58             }
  59 
  60         }
  61         catch(Exception ex){
  62             logger.error("error",ex);
  63         }
  64 
  65         JokeResponse jr = new JokeResponse();
  66         jr.setResponse(ret);
  67         return jr;
  68     }
  69 }

   1 package chucknorris.bitarus.allowed.org;
   2 import com.google.gson.annotations.SerializedName;
   3 
   4 public class Joke{
   5  
   6     @SerializedName("categories")
   7     private String[] categories;
   8     @SerializedName("created_at")
   9     private String createdAt;
  10     @SerializedName("icon_url")
  11     private String iconUrl;
  12     @SerializedName("id")
  13     private String id;
  14     @SerializedName("updated_at")
  15     private String updatedAt;
  16     @SerializedName("url")
  17     private String url;
  18     @SerializedName("value")
  19     private String value;    
  20 
  21     public String[] getCategories(){
  22         return this.categories;
  23     }
  24 
  25     public String getCreatedAt(){        
  26         return this.createdAt;
  27     }
  28 
  29     public String getIconUrl(){
  30         return this.iconUrl;        
  31     }
  32 
  33     public String getId(){   
  34         return this.id;     
  35     }
  36 
  37     public String getUpdatedAt(){        
  38         return this.updatedAt;
  39     }
  40 
  41     public String getUrl(){    
  42         return this.url;    
  43     }
  44 
  45     public String getValue(){
  46         return this.value;
  47     }
  48 
  49     public void setCategories(String[] categories){
  50         this.categories = categories;
  51     }
  52 
  53     public void setCreatedAt(String createdAt ){        
  54         this.createdAt = createdAt;
  55     }
  56 
  57     public void setIconUrl(String iconUrl){
  58         this.iconUrl=iconUrl;        
  59     }
  60 
  61     public void setId(String id){   
  62         this.id=id;     
  63     }
  64 
  65     public void setUpdatedAt(String updatedAt){        
  66         this.updatedAt=updatedAt;
  67     }
  68 
  69     public void setUrl(String url){    
  70         this.url=url;    
  71     }
  72 
  73     public void setValue(String value){
  74         this.value=value;
  75     }
  76 }

   1 package chucknorris.bitarus.allowed.org;
   2 import com.google.gson.annotations.SerializedName;
   3 
   4 public class JokeResponse{
   5  
   6     @SerializedName("response")
   7     private String response;    
   8 
   9     public String getResponse(){
  10         return this.response;
  11     }
  12 
  13     public void setResponse(String response){
  14         this.response = response;
  15     }
  16 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   4 import org.springframework.boot.SpringApplication;
   5 import org.springframework.context.annotation.ComponentScan;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 
   9 @ComponentScan //scans for @Component beans 
  10 @EnableAutoConfiguration
  11 public class Application {
  12     private static Logger logger;
  13 
  14     public static void main(String[] args) {
  15         logger = LoggerFactory.getLogger(Application.class);
  16         logger.info("Starting application");
  17         SpringApplication.run(Application.class, args);
  18     }
  19 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import org.springframework.stereotype.Controller;
   4 import org.springframework.web.bind.annotation.GetMapping;
   5 import org.springframework.ui.Model;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 import org.springframework.web.bind.annotation.ResponseBody;
   9 
  10 import java.io.BufferedReader;
  11 import java.io.InputStreamReader;
  12 import java.io.OutputStream;
  13 import java.net.HttpURLConnection;
  14 import java.net.URL;
  15 import org.springframework.http.HttpMethod;
  16 import com.fasterxml.jackson.databind.ObjectMapper;
  17 import java.util.stream.Stream;
  18 import java.util.stream.Collectors;
  19 import java.util.List;
  20 import java.util.ArrayList;
  21 import org.springframework.beans.factory.annotation.Value;
  22 import io.swagger.v3.oas.annotations.Operation;
  23 import io.swagger.v3.oas.annotations.tags.Tag;
  24 import com.querydsl.jpa.impl.JPAQueryFactory;
  25 
  26 @Tag(name="CNJokeController")
  27 @Controller
  28 public class ChuckNorrisController{
  29     private final Logger logger = LoggerFactory.getLogger(ChuckNorrisController.class);
  30 
  31     @Value("${chucknorris.url}")
  32     private String chuckNorrisURL;
  33     private ObjectMapper objectMapper;
  34     private JokeRepository repo;
  35     private JPAQueryFactory queryFactory;
  36     private JokeMapper jokeMapper;
  37 
  38     public ChuckNorrisController(JokeRepository repo, JPAQueryFactory queryFactory, 
  39       JokeMapper jokeMapper){
  40         logger.info("ChuckNorrisController created");
  41         this.objectMapper = new ObjectMapper();
  42         this.repo = repo;
  43         this.queryFactory = queryFactory;
  44         this.jokeMapper = jokeMapper;
  45     }
  46 
  47     @GetMapping("/chucknorris")
  48     @ResponseBody
  49     @Operation(summary="Gets joke",  description="Gets a Chuck Norris random joke.")
  50     // http://localhost:8080/chucknorris
  51     public JokeResponse chucknorris() {
  52         String ret = "";
  53         Joke joke=null;
  54 
  55         try {
  56             URL url = new URL(chuckNorrisURL);
  57             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
  58             connection.connect();
  59             logger.info( Integer.toString(connection.getResponseCode() ));
  60 
  61             try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"))) {
  62                 StringBuilder response = new StringBuilder();
  63                 String responseLine = null;
  64                 while ((responseLine = br.readLine()) != null) {
  65                     response.append(responseLine.trim());
  66                 }
  67 
  68                 joke = this.objectMapper.readValue(response.toString(), Joke.class);
  69                 List<Joke> jokesList = new ArrayList<Joke>();
  70                 jokesList.add(joke);
  71                 List<Joke> jokesList2 = jokesList.stream().map( item -> {
  72                     item.setValue(item.getValue().toUpperCase());
  73                     return item;
  74                 } ).toList();
  75                 joke = jokesList2.get(0);
  76                 ret = joke.getValue();
  77 
  78                 JokeEntity je = new JokeEntity();
  79                 je.setJoke(joke.getValue());
  80                 JokeEntity saved = repo.saveAndFlush(je);
  81                 logger.info( repo.count()  + " " + saved  );
  82             }
  83 
  84         }
  85         catch(Exception ex){
  86             logger.error("error",ex);
  87         }
  88 
  89         return jokeMapper.jokeToJokeResponse(joke);
  90     }
  91 
  92     @GetMapping("/getsavedjokes")
  93     @ResponseBody
  94     @Operation(summary="Gets saved jokes",  description="Gets saved Chuck Norris jokes.")
  95     public List<JokeProjection> getSavedJokes() {
  96         QJokeEntity jokeEntity = QJokeEntity.jokeEntity;
  97         return queryFactory
  98                 .select( new QJokeProjection( jokeEntity.id , jokeEntity.joke )  )
  99                 .from(jokeEntity)
 100                 .fetch();
 101     }
 102 
 103     @GetMapping("/getsavedjokebyid")
 104     @ResponseBody
 105     @Operation(summary="Get saved joke by id",
 106       description="Get saved Chuck Norris joke by id.")
 107     public JokeProjection getSavedJokeById(Long jokeId) {
 108         QJokeEntity jokeEntity = QJokeEntity.jokeEntity;
 109         List<JokeProjection> ret = queryFactory
 110                 .select( new QJokeProjection( jokeEntity.id , jokeEntity.joke )  )
 111                 .from(jokeEntity)
 112                 .where(jokeEntity.id.eq(jokeId))
 113                 .fetch();
 114         if(ret.size() > 0) return ret.get(0);
 115         return null;
 116     }
 117 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import jakarta.persistence.Entity;
   4 import jakarta.persistence.GeneratedValue;
   5 import jakarta.persistence.GenerationType;
   6 import jakarta.persistence.Id;
   7 
   8 @Entity
   9 public class JokeEntity{
  10   @Id
  11   @GeneratedValue(strategy=GenerationType.AUTO)
  12   private Long id;
  13   private String joke;
  14 
  15   public JokeEntity(){
  16   }
  17 
  18   public String getJoke(){
  19     return this.joke;
  20   }
  21 
  22   public void setJoke(String joke){
  23     this.joke=joke;
  24   }
  25 
  26   public Long getId(){
  27     return this.id;
  28   }
  29 
  30   public void setId(Long id){
  31     this.id=id;
  32   }
  33 
  34   @Override
  35   public String toString(){
  36     return String.format("<Joke %d %s>", this.id,  this.joke);
  37   }
  38 }

   1 package com.mooo.bitarus.chucknorris;
   2 // import com.fasterxml.jackson.annotation.JsonProperty
   3 // @JsonProperty("propInJSON")
   4 public class Joke{
   5     private String[] categories;
   6     private String created_at;
   7     private String icon_url;
   8     private String id;
   9     private String updated_at;
  10     private String url;
  11     private String value;
  12 
  13     public String[] getCategories(){
  14         return this.categories;
  15     }
  16 
  17     public String getCreated_at(){
  18         return this.created_at;
  19     }
  20 
  21     public String getIcon_url(){
  22         return this.icon_url;
  23     }
  24 
  25     public String getId(){
  26         return this.id;
  27     }
  28 
  29     public String getUpdated_at(){
  30         return this.updated_at;
  31     }
  32 
  33     public String getUrl(){
  34         return this.url;
  35     }
  36 
  37     public String getValue(){
  38         return this.value;
  39     }
  40 
  41     public void setCategories(String[] categories){
  42         this.categories = categories;
  43     }
  44 
  45     public void setCreated_at(String createdAt){
  46         this.created_at = created_at;
  47     }
  48 
  49     public void setIcon_url(String iconUrl){
  50         this.icon_url=icon_url;
  51     }
  52 
  53     public void setId(String id){
  54         this.id=id;
  55     }
  56 
  57     public void setUpdated_at(String updatedAt){
  58         this.updated_at=updated_at;
  59     }
  60 
  61     public void setUrl(String url){
  62         this.url=url;
  63     }
  64 
  65     public void setValue(String value){
  66         this.value=value;
  67     }
  68 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import org.mapstruct.Mapper;
   4 import org.mapstruct.Mapping;
   5 
   6 @Mapper(componentModel = "spring")
   7 public interface JokeMapper {
   8 
   9     @Mapping(source = "value" , target = "response")
  10     JokeResponse jokeToJokeResponse(Joke joke);
  11 
  12     @Mapping(source = "response", target = "value")
  13     Joke jokeResponseToJoke(JokeResponse jokeResponse);
  14 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import com.querydsl.core.annotations.QueryProjection;
   4 
   5 public record JokeProjection(Long id, String joke) {
   6 
   7     @QueryProjection
   8     public JokeProjection {
   9     }
  10 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import org.springframework.data.jpa.repository.JpaRepository;
   4 import org.springframework.stereotype.Repository;
   5 
   6 @Repository
   7 public interface JokeRepository extends JpaRepository<JokeEntity,Long>{
   8 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 public class JokeResponse{
   4     private String response;
   5 
   6     public JokeResponse(){}
   7 
   8     public JokeResponse(String response){
   9       this.response = response;
  10     }
  11 
  12     public String getResponse(){
  13         return this.response;
  14     }
  15 
  16     public void setResponse(String response){
  17         this.response = response;
  18     }
  19 }

   1 package com.mooo.bitarus.chucknorris;
   2 
   3 import org.springframework.context.annotation.Configuration;
   4 import jakarta.persistence.PersistenceContext;
   5 import org.springframework.context.annotation.Bean;
   6 import com.querydsl.jpa.impl.JPAQueryFactory;
   7 import jakarta.persistence.EntityManager;
   8 
   9 @Configuration
  10 class QueryDslConfiguration {
  11 
  12     @PersistenceContext
  13     private EntityManager em;
  14 
  15     @Bean
  16     public JPAQueryFactory jpaQueryFactory() {
  17         return new JPAQueryFactory(em);
  18     }
  19 }