br.com.jarch.faces.util.JsfUtils Maven / Gradle / Ivy

Go to download
package br.com.jarch.faces.util;

import br.com.jarch.core.exception.FileException;
import br.com.jarch.core.model.MultiTenant;
import br.com.jarch.core.util.BeanValidationUtils;
import br.com.jarch.core.util.BundleUtils;
import br.com.jarch.core.util.ErrorUtils;
import br.com.jarch.util.FileUtils;
import br.com.jarch.core.type.FieldType;
import br.com.jarch.core.type.FileType;
import br.com.jarch.util.LogUtils;
import br.com.jarch.util.StringUtils;
import org.primefaces.PrimeFaces;
import org.primefaces.util.ComponentTraversalUtils;

import javax.enterprise.context.Dependent;
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.context.Flash;
import javax.inject.Named;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static br.com.jarch.core.ConstantCore.MULTITENANTID;

@Dependent
@Named
public class JsfUtils {

    private static final String SESSION_ONCE = "session.once.";
    private static final String JARCH_REDIRECT_LOGOUT = "jarch.redirectLogout";
    private static final String JARCH_REDIRECT_EXPIRED = "jarch.redirectExpired";
    private static final String JARCH_TIME_OUT_SESSION = "jarch.timeOutSession";

    public static  T getAttributeApplication(String nameAttribute) {
        return (T) getApplication().getAttribute(nameAttribute);
    }

    public static  T getAttributeApplication(Class clazz, String nameAttribute) {
        return clazz.cast(getApplication().getAttribute(nameAttribute));
    }

    public static void setAttributeApplication(String nameAttribute, Object value) {
        getApplication().setAttribute(nameAttribute, value);
    }

    public static  T getAttributeSession(Class clazz, String nameAttribute) {
        return clazz.cast(getSession().getAttribute(nameAttribute));
    }

    public static  T getAttributeSession(String nameAttribute) {
        return (T) getSession().getAttribute(nameAttribute);
    }

    public static void setAttributeSession(String nameAttribute, Object value) {
        getSession().setAttribute(nameAttribute, value);
    }

    public static  T getAttributeRequest(String nameAttribute) {
        return (T) getRequest().getAttribute(nameAttribute);
    }

    public static void setAttributeRequest(String nameAttribute, Object value) {
        getRequest().setAttribute(nameAttribute, value);
    }

    public static Object getAttributeFlash(String nameAttribute) {
        return getFlash().get(nameAttribute);
    }

    public static void setAttributeFlash(String nameAttribute, Object value) {
        getFlash().put(nameAttribute, value);
    }

    public static  T getAttributeOnce(String nameAttribute) {
        return getAttributeOnce(nameAttribute, false);
    }

    public static  T getAttributeOnce(String nameAttribute, boolean keep) {
        Object value = getAttributeSession(SESSION_ONCE + nameAttribute);

        if (!keep) {
            getSession().removeAttribute(SESSION_ONCE + nameAttribute);
        }

        return (T) value;
    }

    public static void setAttributeOnce(String nameAttribute, Object value) {
        setAttributeSession(SESSION_ONCE + nameAttribute, value);
    }

    public static String getParameterRequest(String nameAttribute) {
        return getRequest().getParameter(nameAttribute);
    }

    public static String getParameterRequest(String nameAttribute, String valueDefault) {
        String result = getRequest().getParameter(nameAttribute);

        if (result == null || result.isBlank()) {
            result = valueDefault;
        }

        return result;
    }

    public static Map getRequestParameterMap() {
        return FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
    }

    public static Map getRequestMap() {
        return FacesContext.getCurrentInstance().getExternalContext().getRequestMap();
    }

    public static Map getSessionMap() {
        return FacesContext.getCurrentInstance().getExternalContext().getSessionMap();
    }

    public static Map getApplicationMap() {
        return FacesContext.getCurrentInstance().getExternalContext().getApplicationMap();
    }

    public static ServletContext getApplication() {
        return getRequest().getServletContext();
    }

    public static HttpSession getSession() {
        return getRequest().getSession();
    }

    public static HttpSession getSession(boolean create) {
        return getRequest().getSession(create);
    }

    public static HttpServletRequest getRequest() {
        return (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
    }

    public static HttpServletResponse getResponse() {
        return (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse();
    }

    public static Flash getFlash() {
        return FacesContext.getCurrentInstance().getExternalContext().getFlash();
    }

    public static String getContextPath() {
        HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
        return request.getContextPath();
    }

    public static Boolean redirect(String pagina) {
        FacesContext faces = FacesContext.getCurrentInstance();
        ExternalContext context = faces.getExternalContext();

        try {
            context.redirect(pagina);
            return true;
        } catch (IOException ex) {
            addMessageError("", ex.getMessage());
        }

        return false;
    }

    public static void dispatch(String pagina) {
        FacesContext faces = FacesContext.getCurrentInstance();
        ExternalContext context = faces.getExternalContext();

        try {
            context.dispatch(pagina);
        } catch (IOException ex) {
            ex.printStackTrace();
            addMessageError("", ex.getMessage());
        }
    }

    public static void renderResponse() {
        FacesContext.getCurrentInstance().renderResponse();
    }

    public static void removeAttributeSession(String nameAttribute) {
        getSession().removeAttribute(nameAttribute);
    }

    public static void responseComplete() {
        FacesContext context = FacesContext.getCurrentInstance();
        context.responseComplete();
    }

    public static FacesContext getFacesContext() {
        return FacesContext.getCurrentInstance();
    }

    public static void downloadArquivo(File arquivo, String nomeArquivo, FileType arquivoType) {
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletResponse response = (HttpServletResponse) context.getExternalContext().getResponse();

        response.setContentType(arquivoType.getContentType());
        response.setHeader("Content-Disposition", "attachment;filename=\"" + nomeArquivo + "\"");

        try (FileInputStream in = new FileInputStream(arquivo); OutputStream out = response.getOutputStream()) {

            byte[] buf = new byte[(int) arquivo.length()];
            int count;
            while ((count = in.read(buf)) >= 0) {
                out.write(buf, 0, count);
            }
            out.flush();
            context.responseComplete();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void download(byte[] arquivo, String nomeArquivo, FileType arquivoType) {
        try {
            downloadArquivo(FileUtils.getFile(arquivo), nomeArquivo, arquivoType);
        } catch (IOException ex) {
            throw new FileException(ex);
        }
    }

    public static String getPath(String path) {
        ExternalContext externalContext = FacesContext.getCurrentInstance().getExternalContext();
        ServletContext ctx = (ServletContext) externalContext.getContext();
        String realPath = ctx.getRealPath(path) + File.separator;

        if ("null/".equals(realPath)) {
            realPath = ctx.getAttribute("javax.servlet.context.tempdir").toString() + File.separator + path;
        }

        return realPath;
    }

    public static Object resolveExpressionLanguage(String expression) {
        if (expression == null || expression.isEmpty()) {
            return null;
        }

        String exprEl = expression.startsWith("#{") ? expression : "#{" + expression + "}";

        try {
            return FacesContext
                    .getCurrentInstance()
                    .getApplication()
                    .evaluateExpressionGet(FacesContext.getCurrentInstance(), exprEl, Object.class);
        } catch (Exception e) {
            LogUtils.generate("ERRO EL: " + exprEl);
            LogUtils.generate(e);
            JavaScriptUtils.showMessageHeaderError(e);
            return null;
//            throw e;
        }
    }

    public static void addCallbackParam(String key, Object value) {
        PrimeFaces.current().ajax().addCallbackParam(key, value);
    }

    public static String getUri() {
        return ((HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest()).getRequestURI();
    }

    public static String getUrl() {
        return ((HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest()).getRequestURL().toString();
    }

    public static String getUrlWithQueryParams() {
        String url = getUrl();
        String queryString = getQueryString();

        if (queryString == null)
            queryString = "";

        return url.replace(queryString, "");
    }

    public static String getScheme() {
        return ((HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest()).getScheme();
    }

    public static int getPort() {
        return ((HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest()).getLocalPort();
    }

    public static String getServerName() {
        return ((HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest()).getServerName();
    }

    public static boolean existsComponentId(String id) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        UIComponent component = ComponentTraversalUtils.firstWithId(id, facesContext.getViewRoot());
        return component != null;
    }

    public static String findComponentClientId(String id) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        UIComponent component = ComponentTraversalUtils.firstWithId(id, facesContext.getViewRoot());
        return component.getClientId(facesContext);
    }

    public static void addMessageError(Exception ex) {
        List errors = ErrorUtils.messagesErro(ex);

        errors.forEach(JsfUtils::addMessageError);

        if (FacesContext.getCurrentInstance().getMessageList().isEmpty()) {
            addMessageError(BundleUtils.messageBundle("label.erroImprevisto"), BundleUtils.messageBundle("message.ocorreuErroImprevistoContactarAdministradorSistema"));
        }
    }

    public static void addMessageError(String mensagem) {
        addMessageError("", mensagem);
    }

    public static void addMessageError(String titulo, String mensagem) {
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage(FacesMessage.SEVERITY_ERROR, titulo, mensagem));
    }

    public static void addMessageError(List erros) {
        String msgErros = generateLinesLog(erros);
        addMessageError("", msgErros);
    }

    public static boolean hasMessageError() {
        return FacesContext
            .getCurrentInstance()
            .getMessageList()
            .stream()
            .anyMatch(m -> m.getSeverity().equals(FacesMessage.SEVERITY_ERROR));
    }

    public static void addMessageFatal(String mensagem) {
        addMessageFatal("", mensagem);
    }

    public static void addMessageFatal(String titulo, String mensagem) {
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage(FacesMessage.SEVERITY_FATAL, titulo, mensagem));
    }

    public static void addMessageFatal(List erros) {
        String msgErros = generateLinesLog(erros);
        addMessageFatal("", msgErros);
    }

    public static boolean hasMessageFatal() {
        return FacesContext
            .getCurrentInstance()
            .getMessageList()
            .stream()
            .anyMatch(m -> m.getSeverity().equals(FacesMessage.SEVERITY_FATAL));
    }

    public static void addMessageWarn(String mensagem) {
        addMessageWarn("", mensagem);
    }

    public static void addMessageWarn(String titulo, String mensagem) {
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage(FacesMessage.SEVERITY_WARN, titulo, mensagem));
    }

    public static void addMessageWarn(List erros) {
        String msgErros = generateLinesLog(erros);

        addMessageWarn("", msgErros);
    }

    public static boolean hasMessageWarn() {
        return FacesContext
            .getCurrentInstance()
            .getMessageList()
            .stream()
            .anyMatch(m -> m.getSeverity().equals(FacesMessage.SEVERITY_WARN));
    }

    public static void addMessageInfo(String mensagem) {
        addMessageInfo("", mensagem);
    }

    public static void addMessageInfo(String titulo, String mensagem) {
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage(FacesMessage.SEVERITY_INFO, titulo, mensagem));
    }

    public static void addMessageInfo(List erros) {
        String msgErros = generateLinesLog(erros);

        addMessageInfo("", msgErros);
    }

    public static boolean hasMessageInfo() {
        return FacesContext
            .getCurrentInstance()
            .getMessageList()
            .stream()
            .anyMatch(m -> m.getSeverity().equals(FacesMessage.SEVERITY_INFO));
    }

    public static String formatColumnDataTable(FieldType fieldType, String row, String field) {
        Object value = JsfUtils.resolveExpressionLanguage(row + "['" + field + "']");
        return fieldType.format(value);
    }

    public static String formatColumnDataTable(FieldType fieldType, Object value) {
        return fieldType.format(value);
    }

    public static String formatMessageRequired(String label) {
        if (label == null || label.isBlank())
            return label;

        String newLabel;

        if (BundleUtils.exists(label)) {
            newLabel = BundleUtils.messageBundle(label);
        } else {
            newLabel = "#" + label;
        }

        return BeanValidationUtils.messageBundleParam("message.required", newLabel);
    }

    public static String getQueryString() {
        if (FacesContext.getCurrentInstance() == null
            || FacesContext.getCurrentInstance().getExternalContext() == null
            || FacesContext.getCurrentInstance().getExternalContext().getRequest() == null) {
            return null;
        }

        HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
        return request.getQueryString();
    }

    public static void updateComponent(String id) {
        PrimeFaces.current().ajax().update(findComponentClientId(id));
    }

    public static void updateComponentIfExists(String id) {
        if (existsComponentId(id)) {
            String component = findComponentClientId(id);
            if (component != null) {
                PrimeFaces.current().ajax().update(component);
            }
        }
    }

    public static void updateComponents(List ids) {
        List idsComplete = ids.stream().map(JsfUtils::findComponentClientId).collect(Collectors.toList());
        PrimeFaces.current().ajax().update(idsComplete);
    }

    public static boolean isSession() {
        return FacesContext.getCurrentInstance() != null
            && FacesContext.getCurrentInstance().getExternalContext() != null
            && FacesContext.getCurrentInstance().getExternalContext().getRequest() != null
            && getSession(false) != null;
    }

    public static void sessionExpired() {
//        getSession().invalidate();

        String redirectLogout = getRedirectExpired();
        String redirect = getContextPath() + redirectLogout;

        JavaScriptUtils.showMessageBodyErrorRedirect(redirect,
                BundleUtils.messageBundle("message.sessaoExpirada"),
                BundleUtils.messageBundle("message.tempoInatividadeEsgotado"));
    }

    public static String getRedirectLogout() {
        String redirectLogout = null;
        try {
            redirectLogout = JsfUtils.getAttributeApplication(JARCH_REDIRECT_LOGOUT);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        if (StringUtils.isNullOrEmpty(redirectLogout))
            redirectLogout = "/paginas/login/login.jsf";

        return redirectLogout;
    }

    public static void setRedirectLogout(String redirectLogout) {
        setAttributeApplication(JARCH_REDIRECT_LOGOUT, redirectLogout);
    }

    public static String getRedirectExpired() {
        Object redirectExpired = JsfUtils.getAttributeApplication(JARCH_REDIRECT_EXPIRED);

        if (redirectExpired == null || redirectExpired.toString().isBlank()) {
            redirectExpired = "/paginas/login/login.jsf";

            if (!redirectExpired.toString().contains("Tenant")) {
                if (redirectExpired.toString().contains("?"))
                    redirectExpired += "&";
                else
                    redirectExpired += "?";

                redirectExpired += "multiTenantId=" + MultiTenant.getInstance().get();
            }
        }

        var result = redirectExpired.toString();


        return result;

    }

    public static void setRedirectExpired(String redirectExpired) {
        setAttributeApplication(JARCH_REDIRECT_EXPIRED, redirectExpired);
    }

    public static int getTimeOutApplication() {
        Object timeOut = getAttributeApplication(JARCH_TIME_OUT_SESSION);

        int maxInactiveInterval = getSession(false).getMaxInactiveInterval();

        int result;
        if (timeOut == null) {
            result = getSession(false).getMaxInactiveInterval() - 1;
        } else {
            result = (int) timeOut;

            if (result >= maxInactiveInterval) {
                result = maxInactiveInterval - 1;
            }
        }

        return result;
    }

    public static void setTimeOutApplication(int timeOutSeconds) {
        setAttributeApplication(JARCH_TIME_OUT_SESSION, timeOutSeconds);
    }

    public static void updateTimerSession() {
        updateComponentIfExists("timerSessionApplication");
    }

    public static String getOnlyNamePageCurrent() {
        return getOnlyNamePage(getUrl());
    }

    public static String getOnlyNamePage(String url) {
        String pageAtual = url;

        while (pageAtual.contains("/")) {
            pageAtual = pageAtual.substring(pageAtual.indexOf("/") + 1);
        }

        while (pageAtual.contains(".")) {
            pageAtual = pageAtual.substring(0, pageAtual.indexOf("."));
        }

        return pageAtual;
    }

    private static String generateLinesLog(List erros) {
        StringBuilder msgErros = new StringBuilder();

        for (Exception e : erros) {
            if (msgErros.length() > 0) {
                msgErros.append("
");
            }

            msgErros.append(e.getMessage());
        }
        return msgErros.toString();
    }

    public static boolean setQueryStringMultiTenant() {
        String tenantStr = JsfUtils.getParameterRequest(MULTITENANTID);

        if (tenantStr != null && !tenantStr.isEmpty()) {
            MultiTenant.getInstance().set(Long.parseLong(tenantStr));
            return true;
        }

        return false;
    }
}