Skip to content
Snippets Groups Projects
Select Git revision
  • 126cc397a38134247a5bcb4ba8ef8e7797592cff
  • main default protected
2 results

App.js

Blame
  • FTPResource.java 8.04 KiB
    package fil.sr2.flopbox;
    
    import jakarta.ws.rs.*;
    import jakarta.ws.rs.core.*;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URI;
    import java.util.List;
    
    @Path("/ftps")
    public class FTPResource {
    
        private FTPService ftpService;
        // Endpoints pour gérer la configuration des serveurs FTP
    
        public FTPResource(FTPService ftpService) {
            this.ftpService = ftpService;
        }
    
        public FTPResource() {
            this.ftpService = new FTPService();
        }
    
        @GET
        @Produces(MediaType.APPLICATION_JSON)
        public Response listFTPServers() {
            System.out.println("listFTPServers()");
            List<FTPServerConfig> servers = FTPServerRepository.getInstance().getAllServers();
            return Response.ok(servers).build();
        }
    
        @POST
        @Consumes(MediaType.APPLICATION_JSON)
        public Response addFTPServer(FTPServerConfig config, @Context UriInfo uriInfo) {
            System.out.println("addFTPServer()");
            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()).build();
        }
    
        @DELETE
        @Path("/{alias}")
        public Response removeFTPServer(@PathParam("alias") String alias) {
            System.out.println("removeFTPServer()");
            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) {
            System.out.println("updateFTPServer()");
            boolean updated = FTPServerRepository.getInstance().updateServer(alias, newConfig);
            return updated ? Response.ok(newConfig).build()
                    : Response.status(Response.Status.NOT_FOUND).build();
        }
    
        // --- Endpoints pour les opérations FTP ---
    
        @GET
        @Path("/list/{alias}")
        @Produces(MediaType.APPLICATION_JSON)
        public Response getFTPRoot(
                @PathParam("alias") String alias,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass) {
            System.out.println("getFTPRoot()");
            try {
                FTPService.FtpNode tree = ftpService.getResourceTree(alias, "", user, pass);
                return Response.ok(tree).build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                        .entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        @GET
        @Path("/list/{alias}/{path: .+}")
        @Produces(MediaType.APPLICATION_JSON)
        public Response getFTPTree(
                @PathParam("alias") String alias,
                // Le chemin peut être vide (pour la racine) ou multiple segments
                @PathParam("path") String path,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass) {
            System.out.println("getFTPTree()");
            try {
                FTPService.FtpNode tree = ftpService.getResourceTree(alias, path, user, pass);
                return Response.ok(tree).build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                        .entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        // GET pour récupérer la structure d'un répertoire ou d'un fichier
        @GET
        @Path("/{alias}/{path: .+}")
        @Produces(MediaType.APPLICATION_JSON)
        public Response getFTPResource(
                @PathParam("alias") String alias,
                @PathParam("path") String path,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass) {
            System.out.println("getFTPResource()");
            try {
                FTPService.FtpNode root = ftpService.getResourceTree(alias, path, user, pass);
                return Response.ok(root).build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                        .entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        // PUT pour uploader un fichier
        @PUT
        @Path("/{alias}/{path: .+}")
        @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) {
            System.out.println("uploadFile()");
            try {
                ftpService.uploadFile(alias, path, user, pass, fileStream);
                return Response.ok().build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.serverError().entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        // POST pour créer une ressource (fichier ou répertoire)
        @POST
        @Path("/{alias}/{path: .+}")
        @Consumes({ MediaType.APPLICATION_OCTET_STREAM, MediaType.TEXT_PLAIN })
        public Response createResource(
                @PathParam("alias") String alias,
                @PathParam("path") String path,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass,
                @HeaderParam("X-Resource-Type") String resourceType,
                InputStream inputStream) {
            System.out.println("createResource()");
            try {
                ftpService.createResource(alias, path, user, pass, resourceType, inputStream);
                return Response.created(URI.create(path)).build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.serverError().entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        // DELETE pour supprimer une ressource (fichier ou dossier récursivement)
        @DELETE
        @Path("/{alias}/{path: .+}")
        public Response deleteResource(
                @PathParam("alias") String alias,
                @PathParam("path") String path,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass) {
            System.out.println("deleteResource()");
            try {
                ftpService.deleteResource(alias, path, user, pass);
                return Response.noContent().build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.serverError().entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    
        // POST pour renommer une ressource
        @POST
        @Path("/{alias}/{path: .+}/rename")
        @Consumes(MediaType.TEXT_PLAIN)
        public Response renameResource(
                @PathParam("alias") String alias,
                @PathParam("path") String oldPath,
                @HeaderParam("X-FTP-User") String user,
                @HeaderParam("X-FTP-Pass") String pass,
                String newPath) {
            System.out.println("renameResource()");
            try {
                ftpService.renameResource(alias, oldPath, newPath, user, pass);
                return Response.ok().build();
            } catch (FTPException e) {
                return Response.status(e.getStatus()).entity(e.getMessage()).build();
            } catch (IOException e) {
                return Response.serverError().entity("Erreur FTP : " + e.getMessage()).build();
            }
        }
    }