master
Maxime ROCHER 3 weeks ago
parent ca0f1509a7
commit 24e80f96f9

@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/WF-WEBAPI/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
</component>
</project>

@ -4,7 +4,7 @@
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/WF-WEBAPI/pom.xml" />
<option value="$PROJECT_DIR$/pom.xml" />
</list>
</option>
</component>

@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/WF-WEB-API.iml" filepath="$PROJECT_DIR$/.idea/WF-WEB-API.iml" />
</modules>
</component>
</project>

@ -1,33 +0,0 @@
package com.example.wfwebapi.config;
import com.example.wfwebapi.security.JwtAuthenticationFilter;
import com.example.wfwebapi.security.JwtTokenProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
public class SecurityConfig {
private final JwtTokenProvider tokenProvider;
public SecurityConfig(JwtTokenProvider tokenProvider) {
this.tokenProvider = tokenProvider;
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(authz -> authz
.requestMatchers("/api/v1/auth/**").permitAll() // par exemple, pour la connexion
.anyRequest().authenticated()
)
.addFilterBefore(new JwtAuthenticationFilter(tokenProvider), UsernamePasswordAuthenticationFilter.class)
.httpBasic(Customizer.withDefaults());
return http.build();
}
}

@ -1,12 +0,0 @@
spring.application.name=WF-WEBAPI
# Utilisation de H2 avec le script d'initialisation
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.sql.init.mode=always
spring.sql.init.schema-locations=classpath:init.sql
spring.jpa.hibernate.ddl-auto=none
spring.h2.console.enabled=true
server.port=8080

@ -1,338 +0,0 @@
-- Suppression des tables
DROP TABLE IF EXISTS Commentary;
DROP TABLE IF EXISTS Favorite;
DROP TABLE IF EXISTS DailyQuote;
DROP TABLE IF EXISTS Quote;
DROP TABLE IF EXISTS Caracter;
DROP TABLE IF EXISTS Source;
DROP TABLE IF EXISTS Record_quiz;
DROP TABLE IF EXISTS Quiz_Question;
DROP TABLE IF EXISTS Quiz;
DROP TABLE IF EXISTS Question;
DROP TABLE IF EXISTS Admin;
DROP TABLE IF EXISTS Users;
DROP TABLE IF EXISTS Image;
-- Création des tables
-------------------------------------------------------------------------
CREATE TABLE Image(
id_img NUMERIC PRIMARY KEY,
imgPath varchar(300) NOT NULL UNIQUE
);
-------------------------------------------------------------------------
CREATE TABLE Users(
id_user SERIAL PRIMARY KEY,
username varchar(50) NOT NULL,
email varchar(50) NOT NULL,
password varchar(100) NOT NULL,
img NUMERIC NOT NULL,
creation date NOT NULL,
CONSTRAINT unique_col UNIQUE (email),
CONSTRAINT fk_img FOREIGN KEY(img) REFERENCES Image(id_img)
);
Create OR REPLACE Function IfUserIsAdmin() RETURNS trigger AS $$
DECLARE
BEGIN
Delete From Admin
where users = OLD.id_user;
RETURN OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger IfUserIsAdmin BEFORE DELETE on Users
FOR EACH ROW
EXECUTE FUNCTION IfUserIsAdmin();
Create OR REPLACE Function DeleteUserFavorite() RETURNS trigger AS $$
DECLARE
BEGIN
Delete From Favorite
where users = OLD.id_user;
RETURN OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger DeleteUserFavorite BEFORE DELETE on Users
FOR EACH ROW
EXECUTE FUNCTION DeleteUserFavorite();
Create OR REPLACE Function DeleteUserCommentary() RETURNS trigger AS $$
DECLARE
BEGIN
Delete From Commentary
where users = OLD.id_user;
RETURN OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger DeleteUserCommentary BEFORE DELETE on Users
FOR EACH ROW
EXECUTE FUNCTION DeleteUserCommentary();
-------------------------------------------------------------------------
CREATE TABLE Admin(
users SERIAL PRIMARY KEY,
CONSTRAINT fk_user FOREIGN KEY(users) REFERENCES Users(id_user)
);
-------------------------------------------------------------------------
CREATE TABLE Question(
id_question SERIAL PRIMARY KEY,
texte text NOT NULL UNIQUE,
answerA varchar(30) NOT NULL,
answerB varchar(30) NOT NULL,
answerC varchar(30) NOT NULL,
answerD varchar(30) NOT NULL,
cAnswer varchar(30) NOT NULL,
CONSTRAINT check_cAnswer CHECK (cAnswer = answerA OR cAnswer = answerB OR cAnswer = answerC OR cAnswer = answerD)
);
-------------------------------------------------------------------------
CREATE TABLE Quiz(
id_quiz SERIAL PRIMARY KEY,
title varchar(40) NOT NULL,
img NUMERIC NOT NULL,
nb_quest numeric Default 0,
CONSTRAINT fk_img FOREIGN KEY(img) REFERENCES Image(id_img)
);
Create OR REPLACE Function DeleteQuiz() RETURNS trigger AS $$
DECLARE
BEGIN
Delete From Quiz_Question
where quiz=OLD.id_quiz;
Delete From Record_quiz
where quiz=OLD.id_quiz;
END;
$$ LANGUAGE plpgsql ;
Create Trigger DeleteQuiz BEFORE DELETE on Quiz
FOR EACH ROW
EXECUTE FUNCTION DeleteQuiz();
-------------------------------------------------------------------------
CREATE TABLE Quiz_Question(
quiz SERIAL NOT NULL,
question SERIAL NOT NULL,
PRIMARY KEY (quiz, question),
CONSTRAINT fk_quiz FOREIGN KEY(quiz) REFERENCES Quiz(id_quiz),
CONSTRAINT fk_question FOREIGN KEY(question) REFERENCES Question(id_question)
);
Create OR REPLACE Function NombreQuestionQuiz() RETURNS trigger AS $$
DECLARE
nb numeric;
BEGIN
IF TG_OP='DELETE' Then
SELECT count(quiz) INTO nb
FROM Quiz_Question
WHERE quiz = OLD.quiz;
Else
SELECT count(quiz) INTO nb
FROM Quiz_Question
WHERE quiz = NEW.quiz;
End IF;
Update Quiz
set nb_quest=nb
where id_quiz=NEW.quiz;
Return OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger NombreQuestionQuiz AFTER INSERT or UPDATE or DELETE on Quiz_Question
FOR EACH ROW
EXECUTE FUNCTION NombreQuestionQuiz();
-------------------------------------------------------------------------
CREATE TABLE Record_quiz(
users SERIAL NOT NULL,
quiz SERIAL NOT NULL,
nbPoint numeric DEFAULT 0,
timeQ numeric DEFAULT 0,
PRIMARY KEY (users, quiz),
CONSTRAINT fk_user FOREIGN KEY(users) REFERENCES Users(id_user),
CONSTRAINT fk_quiz FOREIGN KEY(quiz) REFERENCES Quiz(id_quiz),
CONSTRAINT err_nbPoint CHECK(nbPoint >= 0),
CONSTRAINT err_timeQ CHECK(timeQ >= 0)
);
-------------------------------------------------------------------------
CREATE TABLE Source(
id_source SERIAL PRIMARY KEY,
title varchar(100) NOT NULL,
dateS numeric(4) NOT NULL
);
-------------------------------------------------------------------------
CREATE TABLE Caracter(
id_caracter SERIAL PRIMARY KEY,
caracter varchar(100) NOT NULL,
id_img NUMERIC NOT NULL
);
-------------------------------------------------------------------------
CREATE TABLE Quote(
id_quote SERIAL PRIMARY KEY,
content text NOT NULL,
likes numeric DEFAULT '0',
langue char(2) NOT NULL,
isValide boolean NOT NULL DEFAULT 'false',
reason varchar(100) NOT NULL,
id_caracter SERIAL NOT NULL,
id_source SERIAL NOT NULL,
id_user_verif SERIAL NOT NULL,
CONSTRAINT fk_caracter FOREIGN KEY(id_caracter) REFERENCES Caracter(id_caracter),
CONSTRAINT fk_source FOREIGN KEY(id_source) REFERENCES Source(id_source),
CONSTRAINT fk_userverif FOREIGN KEY(id_user_verif) REFERENCES Users(id_user),
CONSTRAINT err_nbLike CHECK (likes >= 0),
CONSTRAINT err_language CHECK (langue = 'fr' OR langue = 'en')
);
Create OR REPLACE Function DeleteQuoteBEFORE() RETURNS trigger AS $$
DECLARE
BEGIN
Delete From Favorite
where quote=OLD.id_quote;
Delete From Commentary
where quote=OLD.id_quote;
If OLD.id_quote in (Select citation_id From DailyQuote) Then
Update DailyQuote
set citation_id = (Select id_quote
From Quote
Where id_quote!=OLD.id_quote
ORDER BY RAND()
LIMIT 1)
Where citation_id=OLD.id_quote;
END IF;
Return OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger DeleteQuoteBEFORE BEFORE DELETE on Quote
FOR EACH ROW
EXECUTE FUNCTION DeleteQuoteBEFORE();
Create OR REPLACE Function DeleteQuoteAFTER() RETURNS trigger AS $$
DECLARE
nb numeric;
BEGIN
Select count(id_caracter) into nb
from Quote
where id_caracter=OLD.id_caracter;
IF nb <= 1 Then
Delete from Caracter
where id_caracter=OLD.id_caracter;
END IF;
Select count(id_source) into nb
from Quote
where id_source=OLD.id_source;
IF nb <= 1 Then
Delete from Source
where id_source=OLD.id_source;
END IF;
Return OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger DeleteQuoteAFTER AFTER DELETE on Quote
FOR EACH ROW
EXECUTE FUNCTION DeleteQuoteAFTER();
-------------------------------------------------------------------------
CREATE TABLE DailyQuote(
citation_id INT PRIMARY KEY,
FOREIGN KEY (citation_id) REFERENCES Quote(id_quote) ON DELETE CASCADE
);
Create OR REPLACE Function UniqueDailyQuote() RETURNS trigger AS $$
DECLARE
nb numeric;
BEGIN
Select count(*) into nb
from DailyQuote;
IF nb = 0 Then
INSERT INTO DailyQuote (citation_id)
VALUES( (Select id_quote
From Quote
Where id_quote!=OLD.id_quote
ORDER BY RAND()
LIMIT 1 ) );
ELSIF nb>1 then
DELETE From DailyQuote
where citation_id!=NEW.citation_id;
END IF;
RETURN OLD;
END;
$$ LANGUAGE plpgsql ;
Create Trigger UniqueDailyQuote AFTER INSERT or DELETE on DailyQuote
FOR EACH ROW
EXECUTE FUNCTION UniqueDailyQuote();
-------------------------------------------------------------------------
CREATE TABLE Favorite(
users SERIAL NOT NULL,
quote SERIAL NOT NULL,
PRIMARY KEY (users, quote),
CONSTRAINT fk_quote FOREIGN KEY(quote) REFERENCES Quote(id_quote),
CONSTRAINT fk_user FOREIGN KEY(users) REFERENCES Users(id_user)
);
-------------------------------------------------------------------------
CREATE TABLE Commentary(
id_comment SERIAL PRIMARY KEY,
quote SERIAL NOT NULL,
users SERIAL NOT NULL,
dateC date NOT NULL,
comment text NOT NULL,
CONSTRAINT fk_quote FOREIGN KEY(quote) REFERENCES Quote(id_quote),
CONSTRAINT fk_user FOREIGN KEY(users) REFERENCES Users(id_user)
);
-------------------------------------------------------------------------

@ -1,5 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
@ -13,20 +14,9 @@
<version>0.0.1-SNAPSHOT</version>
<name>WF-WEBAPI</name>
<description>WF-WEBAPI</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<server.port>6969</server.port>
<java.version>21</java.version>
</properties>
<dependencies>
@ -73,16 +63,25 @@
<version>0.11.5</version>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.3.1</version>
<configuration>
<encoding>UTF-8</encoding>
<delimiters>
<delimiter>@</delimiter>
</delimiters>
<useDefaultDelimiters>false</useDefaultDelimiters>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,22 @@
package com.example.wfwebapi.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
// Désactive CSRF
.csrf(csrf -> csrf.disable())
// Désactive la protection des frames (utile pour la console H2)
.headers(headers -> headers.frameOptions().disable())
// Autorise toutes les requêtes sans authentification
.authorizeHttpRequests(authorize -> authorize.anyRequest().permitAll());
return http.build();
}
}

@ -0,0 +1,7 @@
package com.example.wfwebapi.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import com.example.wfwebapi.model.Quiz;
public interface QuizRepository extends JpaRepository<Quiz, Long> {
}

@ -0,0 +1,25 @@
# Configuration de la base de données H2 (en mémoire)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
# Initialisation de la BDD avec le script
spring.sql.init.mode=always
spring.sql.init.schema-locations=classpath:init.sql
# Configuration de JPA/Hibernate
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
# Console H2 pour le débogage
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# Port du serveur (filtré via Maven)
server.port=@server.port@
# (Optionnel) Niveaux de log pour SQL
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

@ -0,0 +1,144 @@
-- Suppression des tables (si elles existent)
DROP TABLE IF EXISTS commentary;
DROP TABLE IF EXISTS favorite;
DROP TABLE IF EXISTS daily_quote;
DROP TABLE IF EXISTS quote;
DROP TABLE IF EXISTS caracter;
DROP TABLE IF EXISTS source;
DROP TABLE IF EXISTS record_quiz;
DROP TABLE IF EXISTS quiz_question;
DROP TABLE IF EXISTS quiz;
DROP TABLE IF EXISTS question;
DROP TABLE IF EXISTS admin;
DROP TABLE IF EXISTS users;
DROP TABLE IF EXISTS image;
-- Création des tables
-- Table image (l'id est auto-incrémenté)
CREATE TABLE image (
id_img INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
img_path VARCHAR(300) NOT NULL UNIQUE
);
-- Table users (l'id est auto-incrémenté)
CREATE TABLE users (
id_user INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(50) NOT NULL,
password VARCHAR(100) NOT NULL,
img INTEGER NOT NULL,
creation DATE NOT NULL,
CONSTRAINT unique_col UNIQUE (email),
CONSTRAINT fk_users_img FOREIGN KEY (img) REFERENCES image(id_img)
);
-- Table admin
-- La colonne 'users' doit contenir l'id d'un utilisateur existant (pas auto-incrémenté ici)
CREATE TABLE admin (
users INTEGER PRIMARY KEY,
CONSTRAINT fk_admin_user FOREIGN KEY (users) REFERENCES users(id_user)
);
-- Table question (l'id est auto-incrémenté)
CREATE TABLE question (
id_question INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
texte TEXT NOT NULL UNIQUE,
answer_a VARCHAR(30) NOT NULL,
answer_b VARCHAR(30) NOT NULL,
answer_c VARCHAR(30) NOT NULL,
answer_d VARCHAR(30) NOT NULL,
c_answer VARCHAR(30) NOT NULL,
CONSTRAINT check_c_answer CHECK (c_answer = answer_a OR c_answer = answer_b OR c_answer = answer_c OR c_answer = answer_d)
);
-- Table quiz (l'id est auto-incrémenté)
CREATE TABLE quiz (
id_quiz INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
title VARCHAR(40) NOT NULL,
img INTEGER NOT NULL,
nb_quest NUMERIC DEFAULT 0,
CONSTRAINT fk_quiz_img FOREIGN KEY (img) REFERENCES image(id_img)
);
-- Table quiz_question
-- Les colonnes ici sont des clés étrangères et doivent être de type INTEGER (les valeurs proviennent des tables quiz et question)
CREATE TABLE quiz_question (
quiz INTEGER NOT NULL,
question INTEGER NOT NULL,
PRIMARY KEY (quiz, question),
CONSTRAINT fk_quiz_question_quiz FOREIGN KEY (quiz) REFERENCES quiz(id_quiz),
CONSTRAINT fk_quiz_question_question FOREIGN KEY (question) REFERENCES question(id_question)
);
-- Table record_quiz
CREATE TABLE record_quiz (
users INTEGER NOT NULL,
quiz INTEGER NOT NULL,
nb_point NUMERIC DEFAULT 0,
time_q NUMERIC DEFAULT 0,
PRIMARY KEY (users, quiz),
CONSTRAINT fk_recordquiz_user FOREIGN KEY (users) REFERENCES users(id_user),
CONSTRAINT fk_recordquiz_quiz FOREIGN KEY (quiz) REFERENCES quiz(id_quiz),
CONSTRAINT err_nb_point CHECK (nb_point >= 0),
CONSTRAINT err_time_q CHECK (time_q >= 0)
);
-- Table source (l'id est auto-incrémenté)
CREATE TABLE source (
id_source INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
title VARCHAR(100) NOT NULL,
date_s NUMERIC(4) NOT NULL
);
-- Table caracter (l'id est auto-incrémenté)
CREATE TABLE caracter (
id_caracter INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
caracter VARCHAR(100) NOT NULL,
id_img INTEGER NOT NULL,
CONSTRAINT fk_caracter_image FOREIGN KEY (id_img) REFERENCES image(id_img)
);
-- Table quote (l'id est auto-incrémenté)
CREATE TABLE quote (
id_quote INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
content TEXT NOT NULL,
likes NUMERIC DEFAULT 0,
langue CHAR(2) NOT NULL,
is_valide BOOLEAN NOT NULL DEFAULT FALSE,
reason VARCHAR(100) NOT NULL,
id_caracter INTEGER NOT NULL,
id_source INTEGER NOT NULL,
id_user_verif INTEGER NOT NULL,
CONSTRAINT fk_quote_caracter FOREIGN KEY (id_caracter) REFERENCES caracter(id_caracter),
CONSTRAINT fk_quote_source FOREIGN KEY (id_source) REFERENCES source(id_source),
CONSTRAINT fk_quote_userverif FOREIGN KEY (id_user_verif) REFERENCES users(id_user),
CONSTRAINT err_nb_like CHECK (likes >= 0),
CONSTRAINT err_language CHECK (langue = 'fr' OR langue = 'en')
);
-- Table daily_quote
CREATE TABLE daily_quote (
citation_id INTEGER PRIMARY KEY,
FOREIGN KEY (citation_id) REFERENCES quote(id_quote) ON DELETE CASCADE
);
-- Table favorite
CREATE TABLE favorite (
users INTEGER NOT NULL,
quote INTEGER NOT NULL,
PRIMARY KEY (users, quote),
CONSTRAINT fk_favorite_quote FOREIGN KEY (quote) REFERENCES quote(id_quote),
CONSTRAINT fk_favorite_user FOREIGN KEY (users) REFERENCES users(id_user)
);
-- Table commentary (l'id est auto-incrémenté)
CREATE TABLE commentary (
id_comment INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
quote INTEGER NOT NULL,
users INTEGER NOT NULL,
date_c DATE NOT NULL,
comment TEXT NOT NULL,
CONSTRAINT fk_commentary_quote FOREIGN KEY (quote) REFERENCES quote(id_quote),
CONSTRAINT fk_commentary_user FOREIGN KEY (users) REFERENCES users(id_user)
);
Loading…
Cancel
Save