Widerhall/src/main/java/de/srsoftware/widerhall/web/Rest.java

package de.srsoftware.widerhall.web;

import de.srsoftware.widerhall.Util;
import de.srsoftware.widerhall.data.ListMember;
import de.srsoftware.widerhall.data.MailingList;
import de.srsoftware.widerhall.data.User;
import org.json.simple.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.mail.MessagingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static de.srsoftware.widerhall.Constants.*;
import static de.srsoftware.widerhall.Util.t;

public class Rest extends HttpServlet {
    private static final Logger LOG = LoggerFactory.getLogger(Rest.class);
    private static final String LIST_DISABLE = "list/disable";
    private static final String LIST_EDITABLE = "list/editable";
    private static final String LIST_DETAIL = "list/detail";
    private static final String LIST_ENABLE = "list/enable";
    private static final String LIST_HIDE = "list/hide";
    private static final String LIST_MEMBERS = "list/members";
    private static final String LIST_SHOW = "list/show";
    private static final String LIST_TEST = "list/test";
    private static final String LIST_SUBSCRIBABLE = "list/subscribable";
    private static final String USER_ADD_PERMISSION = "user/addpermission";
    private static final String USER_DROP_PERMISSION = "user/droppermission";
    private static final String USER_LIST = "user/list";
    private static final String MEMBERS = "members";
    private static final String SUCCESS = "success";

    private Map addPermission(String userEmail, String permissions) {
        if (userEmail == null || userEmail.isBlank()) return Map.of(ERROR,"E-Mail-Adresse des Listenmitglieds nicht angegeben!");
        try {
            int perm = Integer.parseInt(permissions);
            var user = User.loadAll(List.of(userEmail)).stream().findAny().orElse(null);
            if (user == null) return Map.of(ERROR,t("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail));
            user.addPermission(perm);
        } catch (NumberFormatException nfe){
            return Map.of(ERROR,"Keine gültigen Berechtigungen übergeben!");
        } catch (SQLException e) {
            LOG.debug("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail,e);
            return Map.of(ERROR,t("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail));
        }
        return Map.of(SUCCESS,"Nutzer-Berechtigungen aktualisiert");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String error = handleGet(req, resp);
        if (error != null) resp.sendError(400,error);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String error = handlePost(req, resp);
        if (error != null) resp.sendError(400,error);
    }

    private Map dropPermission(String userEmail, String permissions) {
        if (userEmail == null || userEmail.isBlank()) return Map.of(ERROR,"Nutzer-Emailadresse fehlt!");
        try {
            int perm = Integer.parseInt(permissions);
            var user = User.loadAll(List.of(userEmail)).stream().findAny().orElse(null);
            if (user == null) return Map.of(ERROR,t("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail));
            user.dropPermission(perm);
        } catch (NumberFormatException nfe){
            return Map.of(ERROR,"Keine gültigen Berechtigungen übergeben!");
        } catch (SQLException e) {
            LOG.debug("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail,e);
            return Map.of(ERROR,t("Laden des Nutzers für die Adresse {} fehlgeschlagen",userEmail));
        }
        return Map.of(SUCCESS,"Nutzer-Berechtigungen aktualisiert");
    }

    private Map enableList(MailingList list, User user, boolean enable) {
        if (list == null) return Map.of(ERROR,"Keine Listen-Email übertragen!");
        if (!list.mayBeAlteredBy(user)) Map.of(ERROR,t("Du bist nicht berechtigt, '{}' zu bearbeiten!",list.email()));
        try {
            list.enable(enable);
            return Map.of(SUCCESS,t("Mailing-Liste '{}' wurde {}!",list.email(),enable ? "aktiviert" : "inaktiviert"));
        } catch (SQLException e) {
            LOG.error("Aktivieren/Inaktivieren der Mailing-Liste fehlgeschlagen: ",e);
            return Map.of(ERROR,t("Aktualisieren der Liste '{}' fehlgeschlagen",list.email()));
        }
    }

    public String handleGet(HttpServletRequest req, HttpServletResponse resp){
        var user = Util.getUser(req);
        var path = Util.getPath(req);

        JSONObject json = new JSONObject();

        if (user != null){
            json.put(USER,user.safeMap());
            switch (path) {
                case USER_LIST:
                    try {
                        json.put("users", (user.hashPermission(User.PERMISSION_ADMIN) ? User.loadAll() : List.of(user)).stream().map(User::safeMap).toList());
                    } catch (SQLException e) {
                        LOG.debug("Laden der Nutzerliste fehlgeschlagen:",e);
                        json.put(ERROR,"Laden der Nutzerliste fehlgeschlagen");
                    }
                    break;
                case LIST_EDITABLE:
                    json.put("lists", MailingList.editableBy(user).stream().map(MailingList::safeMap).toList());
                    break;
                case LIST_SUBSCRIBABLE:
                    json.put("lists", MailingList.subscribable(user).stream().map(MailingList::minimalMap).toList());
                    break;
                default:
                    json.put(ERROR,t("Kein Handler für den Pfad '{}'!",path));
                    break;
            }
        } else {
            switch (path) {
                case LIST_SUBSCRIBABLE:
                    json.put("lists", MailingList.subscribable().stream().map(MailingList::minimalMap).toList());
                    break;
                default:
                    json.put(ERROR,"Nicht eingeloggt!");
            }
        }
        try {
            resp.setContentType("application/json");
            resp.getWriter().println(json.toJSONString());
            return null;
        } catch (IOException e) {
            return t("Konnte Anfrage nicht verarbeiten: {}",e.getMessage());
        }
    }

    public String handlePost(HttpServletRequest req, HttpServletResponse resp){

        var user = Util.getUser(req);
        var path = Util.getPath(req);

        JSONObject json = new JSONObject();
        if (user != null){
            json.put(USER,user.safeMap());

            var list = Util.getMailingList(req);
            var userEmail = req.getParameter(EMAIL);
            var permissions = req.getParameter(PERMISSIONS);
            switch (path) {
                case LIST_DETAIL:
                    json.putAll(listDetail(list,user));
                    break;
                case LIST_DISABLE:
                    json.putAll(enableList(list,user,false));
                    break;
                case LIST_ENABLE:
                    json.putAll(enableList(list,user,true));
                    break;
                case LIST_HIDE:
                    json.putAll(hideList(list,user,true));
                    break;
                case LIST_MEMBERS:
                    json.putAll(listMembers(list,user));
                    break;
                case LIST_SHOW:
                    json.putAll(hideList(list,user,false));
                    break;
                case LIST_TEST:
                    json.putAll(testList(list,user));
                    break;
                case USER_ADD_PERMISSION:
                    if (user.hashPermission(User.PERMISSION_ADMIN)){
                        json.putAll(addPermission(userEmail,permissions));
                    } else json.put(ERROR,"Sie haben nicht die Berechtigung, um Berechtigungen zu ändern!");
                    break;
                case USER_DROP_PERMISSION:
                    if (user.hashPermission(User.PERMISSION_ADMIN)){
                        json.putAll(dropPermission(userEmail,permissions));
                    } else json.put(ERROR,"Sie haben nicht die Berechtigung, um Berechtigungen zu ändern!");
                    break;
                default:
                    json.put(ERROR,t("Kein Handler für den Pfad '{}'!",path));
                    break;
            }
        } else {
            json.put(ERROR,"Nicht eingeloggt!");
        }
        try {
            resp.setContentType("application/json");
            resp.getWriter().println(json.toJSONString());
            return null;
        } catch (IOException e) {
            return t("Konnte Anfrage nicht verarbeiten: {}",e.getMessage());
        }
    }

    private Map<String, String> hideList(MailingList list, User user, boolean hide) {
        if (list == null) return Map.of(ERROR,"Keine Listen-Email übertragen!");
        if (!list.mayBeAlteredBy(user)) Map.of(ERROR,t("You are not allowed to edit '{}'",list.email()));
        try {
            list.hide(hide);
            return Map.of(SUCCESS,t("Mailing-Liste '{}' wurde {}!",list.email(),hide ? "versteckt" : "veröffentlicht"));
        } catch (SQLException e) {
            LOG.error("Veröffentlichen/Verstekcen der Mailing-Liste fehlgeschlagen: ",e);
            return Map.of(ERROR,t("Aktualisieren der Liste '{}' fehlgeschlagen",list.email()));
        }
    }

    private Map listDetail(MailingList list, User user) {
        if (list == null) return Map.of(ERROR,"Keine Listen-Email übertragen!");
        var map = new HashMap<>();
        if (list.hasState(MailingList.STATE_FORWARD_FROM)) map.put("forward_from",true);
        if (list.hasState(MailingList.STATE_FORWARD_ATTACHED)) map.put("forward_attached",true);
        return map;
    }

    private Map<String, Object> listMembers(MailingList list, User user) {
        if (list == null) return Map.of(ERROR,"Keine Listen-Email übertragen!");
        if (!list.membersMayBeListedBy(user)) Map.of(ERROR,t("You are not allowed to list members of '{}'",list.email()));
        try {
            var members = list.members()
                    .stream()
                    .map(ListMember::safeMap)
                    .toList();
            return Map.of(MEMBERS,members);
        } catch (SQLException e) {
            LOG.error("Failed to load member list: ",e);
            return Map.of("error",t("Failed to load member list '{}'",list.email()));
        }
    }

    private Map testList(MailingList list, User user) {
        if (list == null) return Map.of(ERROR,"Keine Listen-Email übertragen!");
        if (!list.mayBeTestedBy(user)) Map.of(ERROR,t("You are not allowed to test '{}'",list.email()));
        try {
            list.test(user);
            return Map.of(SUCCESS,t("Sent test email to {}",user.email()));
        } catch (Exception e) {
            LOG.warn("Senden der Test-Email fehlgeschlagen",e);
            return Map.of(ERROR,t("Senden der Test-Email an {} fehlgeschlagen",user.email()));
        }
    }
}