version 1

pom.xml

@@ -31,18 +31,28 @@
             <artifactId>jersey-hk2</artifactId>
         </dependency>
 
-        <!-- uncomment this to get JSON support:
-         <dependency>
+        <dependency>
             <groupId>org.glassfish.jersey.media</groupId>
-            <artifactId>jersey-media-json-binding</artifactId>
+            <artifactId>jersey-media-json-jackson</artifactId>
+            <version>${jersey.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.jaxrs</groupId>
+            <artifactId>jackson-jaxrs-json-provider</artifactId>
+            <version>2.12.3</version>
         </dependency>
-        -->
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>commons-net</groupId>
+            <artifactId>commons-net</artifactId>
+            <version>3.8.0</version>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/fil/sr2/flopbox/AuthFilter.java

+package fil.sr2.flopbox;
+
+import java.io.IOException;
+import java.util.Map;
+
+import jakarta.annotation.Priority;
+import jakarta.ws.rs.Priorities;
+import jakarta.ws.rs.core.*;
+import jakarta.ws.rs.container.*;
+import jakarta.ws.rs.ext.Provider;
+
+@Provider
+@Priority(Priorities.AUTHENTICATION)
+public class AuthFilter implements ContainerRequestFilter {
+    private static final Map<String, String> USERS = loadUsers();
+
+    /*
+     * @Override
+     * public void filter(ContainerRequestContext requestContext) throws IOException
+     * {
+     * // Récupération de l'en-tête Authorization (ex.
+     * "Bearer flopbox-secret-token")
+     * String authHeader =
+     * requestContext.getHeaderString(HttpHeaders.AUTHORIZATION);
+     * if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+     * requestContext.abortWith(
+     * Response.status(Response.Status.UNAUTHORIZED)
+     * .entity("En-tête Authorization manquant ou invalide")
+     * .build());
+     * return;
+     * }
+     * String token = authHeader.substring("Bearer ".length());
+     * // Vérification du token (dans une implémentation réelle, vérification par
+     * // rapport à une liste de comptes stockés)
+     * if (!"flopbox-secret-token".equals(token)) {
+     * requestContext.abortWith(
+     * Response.status(Response.Status.UNAUTHORIZED)
+     * .entity("Token invalide")
+     * .build());
+     * return;
+     * }
+     * // Si le token est valide, la requête continue.
+     * }
+     */
+
+    @Override
+    public void filter(ContainerRequestContext ctx) throws IOException {
+        String token = extractToken(ctx);
+        if (!isValidToken(token)) {
+            ctx.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
+        }
+    }
+
+    // Method to extract token from the request headers
+    private String extractToken(ContainerRequestContext ctx) {
+        // Extract the "Authorization" header
+        String authorizationHeader = ctx.getHeaderString(HttpHeaders.AUTHORIZATION);
+        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
+            return authorizationHeader.substring(7); // Extract the token after "Bearer "
+        }
+        return null; // No token found
+    }
+
+    private boolean isValidToken(String token) {
+        // You can implement your own validation logic here (e.g., checking against a
+        // database)
+        return USERS.containsKey(token); // Just an example where token is checked against a map
+    }
+
+    private static Map<String, String> loadUsers() {
+        // Implémenter le chargement depuis un fichier (ex. users.properties)
+        return Map.of(
+                "valid-token-1", "User1",
+                "valid-token-2", "User2");
+    }
+}

src/main/java/fil/sr2/flopbox/FTPResource.java

+package fil.sr2.flopbox;
+
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.*;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketException;
+import java.net.URI;
+import java.util.List;
+
+import org.apache.commons.net.ftp.FTP;
+import org.apache.commons.net.ftp.FTPClient;
+
+@Path("/ftps")
+public class FTPResource {
+
+    // GET /ftps - liste des serveurs FTP enregistrés
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public Response listFTPServers() {
+        List<FTPServerConfig> servers = FTPServerRepository.getInstance().getAllServers();
+        return Response.ok(servers).build();
+    }
+
+    // POST /ftps - enregistre un nouveau serveur FTP
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    public Response addFTPServer(FTPServerConfig config, @Context UriInfo uriInfo) {
+        boolean created = FTPServerRepository.getInstance().addServer(config);
+        if (!created) {
+            return Response.status(Response.Status.CONFLICT)
+                    .entity("Alias déjà utilisé").build();
+        }
+        UriBuilder builder = uriInfo.getAbsolutePathBuilder();
+        builder.path(config.getAlias());
+        return Response.created(builder.build()).entity(config).build();
+    }
+
+    // GET /ftps/{alias}/{path} - récupère le contenu d'un répertoire ou d'un
+    // fichier sur le serveur FTP
+    @GET
+    @Path("/{alias}/{path: .+}")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Response getFTPContent(
+            @PathParam("alias") String alias,
+            @PathParam("path") String path,
+            @HeaderParam("X-FTP-User") String ftpUser,
+            @HeaderParam("X-FTP-Pass") String ftpPass) {
+        FTPServerConfig config = FTPServerRepository.getInstance().getServer(alias);
+        if (config == null) {
+            return Response.status(Response.Status.NOT_FOUND)
+                    .entity("Alias de serveur FTP non trouvé").build();
+        }
+        FTPClient ftpClient = new FTPClient();
+        try {
+            ftpClient.connect(config.getHost(), config.getPort());
+            boolean login = ftpClient.login(ftpUser, ftpPass);
+            if (!login) {
+                return Response.status(Response.Status.UNAUTHORIZED)
+                        .entity("Échec de l'authentification FTP").build();
+            }
+            // Pour cet exemple, on se place dans le répertoire demandé et on renvoie la
+            // liste des fichiers.
+            ftpClient.changeWorkingDirectory(path);
+            String[] files = ftpClient.listNames();
+            ftpClient.logout();
+            ftpClient.disconnect();
+            return Response.ok(files).build();
+        } catch (IOException ex) {
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+                    .entity("Erreur FTP : " + ex.getMessage()).build();
+        }
+    }
+
+    @DELETE
+    @Path("/{alias}")
+    public Response removeFTPServer(@PathParam("alias") String alias) {
+        boolean removed = FTPServerRepository.getInstance().removeServer(alias);
+        return removed ? Response.noContent().build() : Response.status(Response.Status.NOT_FOUND).build();
+    }
+
+    @PUT
+    @Path("/{alias}")
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response updateFTPServer(@PathParam("alias") String alias, FTPServerConfig newConfig) {
+        boolean updated = FTPServerRepository.getInstance().updateServer(alias, newConfig);
+        return updated ? Response.ok(newConfig).build() : Response.status(Response.Status.NOT_FOUND).build();
+    }
+
+    @GET
+    @Path("/{alias}/{path: .+}/download")
+    @Produces(MediaType.APPLICATION_OCTET_STREAM)
+    public Response downloadFile(
+            @PathParam("alias") String alias,
+            @PathParam("path") String path,
+            @HeaderParam("X-FTP-User") String user,
+            @HeaderParam("X-FTP-Pass") String pass) {
+
+        FTPServerConfig config = FTPServerRepository.getInstance().getServer(alias);
+        FTPClient ftp = new FTPClient();
+        try {
+            ftp.connect(config.getHost(), config.getPort());
+            ftp.login(user, pass);
+            InputStream is = ftp.retrieveFileStream(path);
+            return Response.ok(is)
+                    .header("Content-Disposition", "attachment; filename=\"" + getFileName(path) + "\"")
+                    .build();
+        } catch (IOException e) {
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+        } finally {
+            try {
+                if (ftp.isConnected()) {
+                    ftp.logout();
+                    ftp.disconnect();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @PUT
+    @Path("/{alias}/{path: .+}/upload")
+    @Consumes(MediaType.APPLICATION_OCTET_STREAM)
+    public Response uploadFile(
+            @PathParam("alias") String alias,
+            @PathParam("path") String path,
+            @HeaderParam("X-FTP-User") String user,
+            @HeaderParam("X-FTP-Pass") String pass,
+            InputStream fileStream) {
+
+        FTPServerConfig config = FTPServerRepository.getInstance().getServer(alias);
+        FTPClient ftp = new FTPClient();
+        try {
+            ftp.connect(config.getHost(), config.getPort());
+            ftp.login(user, pass);
+            boolean success = ftp.storeFile(path, fileStream);
+            return success ? Response.ok().build() : Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+        } catch (IOException e) {
+            return Response.serverError().entity(e.getMessage()).build();
+        } finally {
+            try {
+                if (ftp.isConnected()) {
+                    ftp.logout();
+                    ftp.disconnect();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @POST
+    @Path("/{alias}/{path: .+}/mkdir")
+    public Response createDirectory(
+            @PathParam("alias") String alias,
+            @PathParam("path") String path,
+            @HeaderParam("X-FTP-User") String user,
+            @HeaderParam("X-FTP-Pass") String pass) throws SocketException, IOException {
+
+        FTPClient ftp = new FTPClient();
+        try {
+            FTPServerConfig config = FTPServerRepository.getInstance().getServer(alias);
+            ftp.connect(config.getHost(), config.getPort());
+            ftp.login(user, pass);
+            return ftp.makeDirectory(path) ? Response.created(URI.create(path)).build()
+                    : Response.status(Response.Status.BAD_REQUEST).build();
+        } finally {
+            try {
+                if (ftp.isConnected()) {
+                    ftp.logout();
+                    ftp.disconnect();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @DELETE
+    @Path("/{alias}/{path: .+}/rmdir")
+    public Response deleteDirectory(
+            @PathParam("alias") String alias,
+            @PathParam("path") String path,
+            @HeaderParam("X-FTP-User") String user,
+            @HeaderParam("X-FTP-Pass") String pass) throws SocketException, IOException {
+
+        FTPClient ftp = new FTPClient();
+        try {
+            FTPServerConfig config = FTPServerRepository.getInstance().getServer(alias);
+            ftp.connect(config.getHost(), config.getPort());
+            ftp.login(user, pass);
+            return ftp.removeDirectory(path) ? Response.noContent().build()
+                    : Response.status(Response.Status.NOT_FOUND).build();
+        } finally {
+            try {
+                if (ftp.isConnected()) {
+                    ftp.logout();
+                    ftp.disconnect();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private String getFileName(String path) {
+        return path.substring(path.lastIndexOf('/') + 1);
+    }
+}

src/main/java/fil/sr2/flopbox/FTPServerConfig.java

+package fil.sr2.flopbox;
+
+public class FTPServerConfig {
+    private String alias;
+    private String host;
+    private int port;
+
+    public FTPServerConfig() {
+    }
+
+    public FTPServerConfig(String alias, String host, int port) {
+        this.alias = alias;
+        this.host = host;
+        this.port = port;
+    }
+
+    // Getters et setters
+    public String getAlias() {
+        return alias;
+    }
+
+    public void setAlias(String alias) {
+        this.alias = alias;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+}

src/main/java/fil/sr2/flopbox/FTPServerRepository.java

+package fil.sr2.flopbox;
+
+import java.util.*;
+
+public class FTPServerRepository {
+    private static FTPServerRepository instance = new FTPServerRepository();
+    private Map<String, FTPServerConfig> serverMap = new HashMap<>();
+
+    private FTPServerRepository() {
+    }
+
+    public static FTPServerRepository getInstance() {
+        return instance;
+    }
+
+    public List<FTPServerConfig> getAllServers() {
+        return new ArrayList<>(serverMap.values());
+    }
+
+    public FTPServerConfig getServer(String alias) {
+        return serverMap.get(alias);
+    }
+
+    public boolean addServer(FTPServerConfig config) {
+        if (serverMap.containsKey(config.getAlias())) {
+            return false;
+        }
+        serverMap.put(config.getAlias(), config);
+        return true;
+    }
+
+    public boolean removeServer(String alias) {
+        return serverMap.remove(alias) != null;
+    }
+
+    public boolean updateServer(String alias, FTPServerConfig newConfig) {
+        if (!serverMap.containsKey(alias))
+            return false;
+        serverMap.put(alias, newConfig);
+        return true;
+    }
+}

src/main/java/fil/sr2/flopbox/Main.java

@@ -4,41 +4,26 @@ import org.glassfish.grizzly.http.server.HttpServer;
 import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
 import org.glassfish.jersey.server.ResourceConfig;
 
-import java.io.IOException;
 import java.net.URI;
 
-/**
- * Main class.
- *
- */
 public class Main {
-    // Base URI the Grizzly HTTP server will listen on
     public static final String BASE_URI = "http://localhost:8080/";
 
-    /**
-     * Starts Grizzly HTTP server exposing JAX-RS resources defined in this application.
-     * @return Grizzly HTTP server.
-     */
     public static HttpServer startServer() {
-        // create a resource config that scans for JAX-RS resources and providers
-        // in fil.sr2.flopbox package
-        final ResourceConfig rc = new ResourceConfig().packages("fil.sr2.flopbox");
-
-        // create and start a new instance of grizzly http server
-        // exposing the Jersey application at BASE_URI
+        // On configure Jersey pour scanner le package "com.flopbox" (ressources,
+        // filtres, etc.)
+        final ResourceConfig rc = new ResourceConfig().packages("fil.sr2.flopbox")
+                .register(org.glassfish.jersey.jackson.JacksonFeature.class);
         return GrizzlyHttpServerFactory.createHttpServer(URI.create(BASE_URI), rc);
     }
 
-    /**
-     * Main method.
-     * @param args
-     * @throws IOException
-     */
-    public static void main(String[] args) throws IOException {
+    public static void main(String[] args) {
         final HttpServer server = startServer();
-        System.out.println(String.format("Jersey app started with endpoints available at "
-                + "%s%nHit Ctrl-C to stop it...", BASE_URI));
-        System.in.read();
-        server.stop();
+        System.out.println("FlopBox API démarrée sur " + BASE_URI);
+        try {
+            Thread.currentThread().join();
+        } catch (InterruptedException ex) {
+            System.err.println("Serveur interrompu : " + ex.getMessage());
+        }
     }
 }