RandomCSDBServlet.java

package server.restful.servlets;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.HttpConstraint;
import jakarta.servlet.annotation.ServletSecurity;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import server.restful.common.JSIDPlay2Servlet;
import server.restful.common.async.DefaultThreadFactory;
import server.restful.common.async.HttpAsyncContextRunnable;
import server.restful.common.parameter.ServletParameterParser;
import server.restful.common.parameter.UsageParameter;
import server.restful.common.parameter.requestpath.impl.FileRequestPathServletParametersImpl;
import server.restful.common.validator.MaxRowsValidator;
import server.restful.common.validator.RatingValidator;
import server.restful.common.validator.YearValidator;
import ui.assembly64.*;
import ui.common.Convenience;

import java.io.*;
import java.net.URISyntaxException;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static java.lang.Integer.MIN_VALUE;
import static java.lang.String.valueOf;
import static java.util.stream.Collectors.toList;
import static server.restful.JSIDPlay2Server.*;
import static server.restful.common.IServletSystemProperties.RandomCSDBServlet.MAX_RANDOM_CSDB_IN_PARALLEL;
import static server.restful.common.IServletSystemProperties.RandomCSDBServlet.RANDOM_CSDB_ASYNC_TIMEOUT;
import static server.restful.common.ServletUtil.error;
import static server.restful.common.ServletUtil.info;

@WebServlet(name = "RandomCSDBServlet", displayName = "RandomCSDBServlet", asyncSupported = true, urlPatterns = CONTEXT_ROOT_SERVLET
        + "/random-csdb", description = "Get random CSDB content")
@ServletSecurity(value = @HttpConstraint(rolesAllowed = {ROLE_USER, ROLE_ADMIN}))
public class RandomCSDBServlet extends JSIDPlay2Servlet {

    @SuppressWarnings("unused")
    @Parameters(resourceBundle = "server.restful.servlets.RandomCSDBServletParameters")
    public static class RandomCSDBServletParameters extends UsageParameter {

        private Integer serverId;

        public Integer getServerId() {
            return serverId;
        }

        @Parameter(names = {"--serverId"}, descriptionKey = "SERVER_ID", order = MIN_VALUE + 1)
        public void setServerId(Integer serverId) {
            this.serverId = serverId;
        }

        private Integer maxRows = 200;

        public Integer getMaxRows() {
            return maxRows;
        }

        @Parameter(names = {
                "--maxRows"}, descriptionKey = "MAX_ROWS", validateWith = MaxRowsValidator.class, order = MIN_VALUE + 2)
        public void setMaxRows(Integer maxRows) {
            this.maxRows = maxRows;
        }

        private String category = "music";

        public String getCategory() {
            return category;
        }

        @Parameter(names = {"--category"}, descriptionKey = "CATEGORY", order = MIN_VALUE + 3)
        public void setCategory(String category) {
            this.category = category;
        }

        private List<String> types;

        public List<String> getTypes() {
            return types;
        }

        @Parameter(names = {"--types"}, descriptionKey = "TYPES", order = MIN_VALUE + 4)
        public void setTypes(List<String> types) {
            this.types = types;
        }

        private Integer minRating;

        public Integer getMinRating() {
            return minRating;
        }

        @Parameter(names = {
                "--minRating"}, descriptionKey = "RATING", validateWith = RatingValidator.class, order = MIN_VALUE + 5)
        public void setMinRating(Integer rating) {
            this.minRating = rating;
        }

        private Integer fromYear;

        public Integer getFromYear() {
            return fromYear;
        }

        @Parameter(names = {
                "--fromYear"}, descriptionKey = "FROM_YEAR", validateWith = YearValidator.class, order = MIN_VALUE + 6)
        public void setFromYear(Integer fromYear) {
            this.fromYear = fromYear;
        }

        private Integer toYear;

        public Integer getToYear() {
            return toYear;
        }

        @Parameter(names = {
                "--toYear"}, descriptionKey = "TO_YEAR", validateWith = YearValidator.class, order = MIN_VALUE + 7)
        public void setToYear(Integer toYear) {
            this.toYear = toYear;
        }

        private String handle = "";

        public String getHandle() {
            return handle;
        }

        @Parameter(names = {"--handle"}, descriptionKey = "HANDLE", order = MIN_VALUE + 8)
        public void setHandle(String handle) {
            this.handle = handle;
        }

    }

    private ExecutorService executorService;

    @Override
    public void init() {
        executorService = Executors.newFixedThreadPool(MAX_RANDOM_CSDB_IN_PARALLEL,
                new DefaultThreadFactory("/random-csdb"));
    }

    @Override
    public void destroy() {
        executorService.shutdown();
    }

    /**
     * Get random CSDB SID tune.
     * <p>
     * E.g. {@code http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/random-csdb }
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(RANDOM_CSDB_ASYNC_TIMEOUT);

        executorService.execute(new HttpAsyncContextRunnable(asyncContext, getServletContext()) {

            private Assembly64Client assembly64Client;
            private Integer serverId;
            private String categoryType;

            public void run(HttpServletRequest request, HttpServletResponse response) {
                try {
                    final RandomCSDBServletParameters servletParameters = new RandomCSDBServletParameters();

                    ServletParameterParser parser = new ServletParameterParser(request, response, servletParameters);

                    if (servletParameters.getHelp() || parser.hasException()) {
                        parser.usage();
                        return;
                    }
                    serverId = servletParameters.getServerId();
                    assembly64Client = new Assembly64Client(configuration, serverId, request.isUserInRole(ROLE_ADMIN));
                    Integer maxRows = servletParameters.getMaxRows();
                    String category = servletParameters.getCategory();
                    List<String> types = servletParameters.getTypes();
                    Integer minRating = servletParameters.getMinRating();
                    Integer fromYear = servletParameters.getFromYear();
                    Integer toYear = servletParameters.getToYear();
                    String handle = servletParameters.getHandle();

                    SearchResult searchResult = getRandomSearchResult(maxRows, category, types, minRating, fromYear,
                            toYear, handle);

                    File result = fetchRandomCSDB(parser, searchResult, types);

                    info(getServletContext(), String.format("randomCSDB: %s", result));

                    if (!isComplete()) {
                        response.setHeader("category", searchResult.getCategory().getName());
                        response.setHeader("name", searchResult.getName());
                        response.setHeader("group", searchResult.getGroup());
                        response.setHeader("event", searchResult.getEvent());
                        response.setHeader("handle", searchResult.getHandle());
                        response.setHeader("release",
                                searchResult.getReleased() != null ? valueOf(searchResult.getReleased()) : null);
                        response.setHeader("rating", valueOf(searchResult.getRating()));
                        setOutput(request, response, valueOf(result).replace("\\", "/"));
                    }

                } catch (FileNotFoundException t) {
                    response.setStatus(HttpServletResponse.SC_NO_CONTENT);
                } catch (Throwable t) {
                    response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                    error(getServletContext(), t);
                    setOutput(response, t);
                }
            }

            private SearchResult getRandomSearchResult(Integer maxRows, String category, List<String> types,
                                                       Integer minRating, Integer fromYear, Integer toYear, String handle)
                    throws URISyntaxException, IOException {
                Collection<Presets> presets = assembly64Client.getPresets();
                List<Category> categories = Assembly64Client.categories(presets);
                categoryType = Assembly64Client.categoryType(presets);
                String query = createSearchQuery(category, types, minRating, fromYear, toYear, handle);
                SearchResult[] searchResults = createObjectMapper(categories).readerFor(SearchResult[].class)
                        .readValue(assembly64Client.search(query, 0, maxRows));

                int max = Math.min(searchResults.length, maxRows);
                SearchResult searchResult = searchResults.length > 0 ? searchResults[RANDOM.nextInt(max)] : null;
                if (searchResult == null) {
                    throw new FileNotFoundException("No search results found!");
                }
                return searchResult;
            }

            private File fetchRandomCSDB(ServletParameterParser parser, SearchResult searchResult, List<String> types)
                    throws IOException, URISyntaxException {

                List<ContentEntry> contentEntries = fetchContentEntries(searchResult.getId(),
                        searchResult.getCategory().getId());

                final ContentEntry randomAudioContentEntry = getRandomContentEntry(types, contentEntries);

                FileRequestPathServletParametersImpl randomFileRequestPathServletParameters = new FileRequestPathServletParametersImpl() {

                    @Override
                    public Integer getServerId() {
                        return serverId;
                    }

                    @Override
                    public String getItemId() {
                        return searchResult.getId();
                    }

                    @Override
                    public String getFilePath() {
                        return "/" + randomAudioContentEntry.getPath();
                    }

                    @Override
                    public String getCategoryId() {
                        return valueOf(searchResult.getCategory().getId());
                    }
                };
                return randomFileRequestPathServletParameters.fetchFile(configuration, directoryProperties, parser,
                        hasAdminAccess(request));
            }

            private ContentEntry getRandomContentEntry(List<String> types, List<ContentEntry> contentEntries) throws FileNotFoundException {
                if (types != null) {
                    for (String type : types) {
                        List<ContentEntry> filtered = contentEntries.stream().filter(
                                        entry -> new File(entry.getPath()).getName().toLowerCase(Locale.ENGLISH).endsWith(type))
                                .collect(toList());
                        if (!filtered.isEmpty()) {
                            return filtered.get(RANDOM.nextInt(filtered.size()));
                        }
                    }
                } else {
                    if (!contentEntries.isEmpty()) {
                        return contentEntries.get(RANDOM.nextInt(contentEntries.size()));
                    }
                }
                throw new FileNotFoundException("No content entries found!");
            }

            private String createSearchQuery(String category, List<String> types, Integer minRating,
                                             Integer fromYear, Integer toYear, String handle) {
                List<String> terms = new ArrayList<>();
                if (category != null && !category.isBlank()) terms.add(categoryType + ":" + category);
                if (types != null && !types.isEmpty()) terms.add("type:" + String.join(",", types));
                if (minRating != null && minRating != 0) terms.add("rating:>=" + minRating);
                if (fromYear != null && toYear != null) {
                    int year = (int) (Math.random() * (toYear - fromYear + 1)) + fromYear;
                    terms.add("date:" + year);
                }
                if (handle != null && !handle.isBlank()) terms.add("handle:\"" + handle + "\"");
                return String.join(" ", terms);
            }

            private List<ContentEntry> fetchContentEntries(String id, Integer categoryId) throws IOException {
                return assembly64Client.entries(id, String.valueOf(categoryId)).getContentEntry().stream()
                        .filter(e -> e.getPath() != null && !e.getPath().startsWith(Convenience.MACOSX)).collect(toList());
            }

            private ObjectMapper createObjectMapper(List<Category> categories) {
                ObjectMapper objectMapper = new ObjectMapper();
                JavaTimeModule module = new JavaTimeModule();
                module.addDeserializer(Category.class, new CategoryDeserializer(categories));
                objectMapper.registerModule(module);
                return objectMapper;
            }

        });
    }

}