com.khs.sherpa.endpoint.SherpaEndpoint.java Source code

Introduction

Here is the source code for com.khs.sherpa.endpoint.SherpaEndpoint.java

Source

package com.khs.sherpa.endpoint;

/*
 * Copyright 2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.annotation.security.DenyAll;
import javax.annotation.security.RolesAllowed;

import org.apache.commons.lang3.StringUtils;
import org.reflections.ReflectionUtils;
import org.reflections.Reflections;

import com.google.common.base.Predicates;
import com.khs.sherpa.annotation.Action;
import com.khs.sherpa.annotation.Endpoint;
import com.khs.sherpa.annotation.Param;
import com.khs.sherpa.context.ApplicationContext;
import com.khs.sherpa.context.ApplicationContextAware;
import com.khs.sherpa.exception.NoSuchManagedBeanExcpetion;
import com.khs.sherpa.exception.SherpaRuntimeException;
import com.khs.sherpa.json.service.SessionTokenService;
import com.khs.sherpa.util.MethodUtil;
import com.khs.sherpa.util.SherpaPredicates;

@Endpoint(value = "Sherpa", authenticated = false)
public class SherpaEndpoint implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @RolesAllowed("SHERPA_ADMIN")
    @Action(mapping = "/sherpa/admin/sessions")
    public Object sessions(SessionTokenService service) {
        return service.sessions();
    }

    @RolesAllowed("SHERPA_ADMIN")
    @Action(mapping = "/sherpa/admin/endpoints")
    public Map<String, String> endpoints() {
        Map<String, String> map = new HashMap<String, String>();

        for (Entry<String, Object> entry : applicationContext.getEndpointTypes().entrySet()) {
            String name = entry.getValue().getClass().getAnnotation(Endpoint.class).value();
            if (StringUtils.isEmpty(name)) {
                name = entry.getValue().getClass().getSimpleName();
            }
            map.put(name, entry.getValue().getClass().getName());
        }
        return map;
    }

    @SuppressWarnings("unchecked")
    //   @RolesAllowed("SHERPA_ADMIN")
    @Action(mapping = "/sherpa/admin/describe/{value}")
    public Object describe(@Param("value") String value) {

        List<Map<String, Object>> actions = new ArrayList<Map<String, Object>>();

        Set<Method> methods = null;

        try {
            methods = Reflections.getAllMethods(applicationContext.getType(value),
                    Predicates.and(Predicates.not(SherpaPredicates.withAssignableFrom(Object.class)),
                            ReflectionUtils.withModifier(Modifier.PUBLIC),
                            Predicates.not(ReflectionUtils.withModifier(Modifier.ABSTRACT)),
                            Predicates.not(SherpaPredicates.withGeneric())));
        } catch (NoSuchManagedBeanExcpetion e) {
            throw new SherpaRuntimeException(e);
        }

        for (Method method : methods) {

            Map<String, Object> action = new HashMap<String, Object>();
            actions.add(action);

            action.put("name", MethodUtil.getMethodName(method));

            if (method.isAnnotationPresent(DenyAll.class)) {
                action.put("permission", "DenyAll");
            } else if (method.isAnnotationPresent(RolesAllowed.class)) {
                action.put("permission", "RolesAllowed");
                action.put("roles", method.getAnnotation(RolesAllowed.class).value());
            } else {
                action.put("permission", "PermitAll");
            }

            Map<String, String> params = new HashMap<String, String>();

            Class<?>[] types = method.getParameterTypes();
            Annotation[][] parameters = method.getParameterAnnotations();
            for (int i = 0; i < parameters.length; i++) {
                Class<?> type = types[i];
                Param annotation = null;
                if (parameters[i].length > 0) {
                    for (Annotation an : parameters[i]) {
                        if (an.annotationType().isAssignableFrom(Param.class)) {
                            annotation = (Param) an;
                            break;
                        }
                    }

                }
                if (annotation != null) {
                    params.put(annotation.value(), type.getName());
                }
            }

            if (params.size() > 0) {
                action.put("params", params);
            } else {
                action.put("params", null);
            }

        }

        return actions;
    }

    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
}