@Override public boolean isOperationExists(RestdContext context, RouteBuilder r) { String verb = r.getMethod(); String path = r.getPathTemplate().getTemplate(); for(RequestMappingInfo mapping : allMappings.keySet()) { if(!isSamePath(mapping, path)) { continue; } if(isSameMethod(mapping, verb)) { apiMappings.add(mapping); Object handler = allMappings.get(mapping); String desc = handler.toString(); if(handler instanceof HandlerMethod) { HandlerMethod hm = (HandlerMethod)handler; desc = "spring:" + getHandlerDescription(hm); processHandlerMethod(r, hm); } r.setEnabled(true); r.setExecutable(false); r.setAction(new SpringAction(r.getAction(), desc)); return true; } } return false; }
protected void postConfigure(RestdContext context, RestdModel model, RouteBuilder route, MApiOperationBuilder mo) { RestdConfig c = context.getConfig(); if(null != model) { if (c.isModelAnonymous(model.getName())) { route.setAllowAnonymous(true); } } route.addFailureHandler(context.getApiConfig().getFailureHandler()); JsonSettings settings = new JsonSettings.Builder().setDateTimeFormatter(SwaggerConstants.DATE_TIME_FORMAT, "GMT").build(); route.setExtension(settings); if(null != mo) { if(mo.isAllowAnonymous()) { route.setAllowAnonymous(true); } if(mo.isAllowClientOnly()) { route.setAllowClientOnly(true); } route.setPermissions(mo.getPermissions()); route.setSecurities(mo.getSecurities()); } }
protected Route mappingToRoute(PathTemplateFactory ptf, RequestMappingInfo info, Object handler) { String path = info.getPatternsCondition().getPatterns().iterator().next(); String method = info.getMethodsCondition().getMethods().isEmpty() ? "*" : info.getMethodsCondition().getMethods().iterator().next().name(); RouteBuilder route = new RouteBuilder(method, ptf.createPathTemplate(path)); String desc = handler.toString(); if(handler instanceof HandlerMethod) { desc = LeapOperationSupport.getHandlerDescription((HandlerMethod)handler); } route.setAction(new DescAction(desc)); return route.build(); }
protected void postConfigure(RestdContext context, RestdModel model, RouteBuilder route) { route.setCsrfEnabled(false); route.setExtension(EntityMapping.class, model.getEntityMapping()); postConfigure(context, model, route, null); }
protected void setApiExtension(RouteBuilder route, String name, Object value) { MApiExtension extension = route.getExtension(MApiExtension.class); if (null == extension) { extension = new MApiExtension(); route.setExtension(extension); } extension.setAttribute(name, value); }
protected boolean isOperationExists(RestdContext context, RouteBuilder route) { for(ApiRoute ar : context.getApiConfig().getApiRoutes()) { Route route1 = ar.getRoute(); if(route.getMethod().equalsIgnoreCase(route1.getMethod()) && route.getPathTemplate().getTemplate().equals(route1.getPathTemplate().getTemplate())) { route.setAction(route1.getAction()); route.setEnabled(false); return true; } } for(RestdOperationSupport support : operationSupports) { if(support.isOperationExists(context, route)) { if(null == route.getEnabled()) { route.setEnabled(false); } return route.isDisabledExplicitly(); } } return false; }
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("GET", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addArgument(context, action, QueryOptions.class, "options"); if (null != callback) { callback.postAddArguments(action); } addModelQueryResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
static void withPermsForRead(RestdModel model, RouteBuilder route, String type) { MetaEntity entity = (MetaEntity)model.getAttribute(MetaEntity.class.getName()); if(null != entity) { route.setExtension(entity); route.setAllowAnonymous(entity.getAnonymous()); List<SimpleSecurity> secs = new ArrayList<>(); List<MApiSecurityReq> seqs = new ArrayList<>(); if(null != entity.getUserPerms()) { SimpleSecurity.Builder sec = new SimpleSecurity.Builder(); sec.setUserRequired(true); sec.setPermissions(getReadScope(entity.getUserPerms(), type)); secs.add(sec.build()); seqs.add(new MApiSecurityReq(SecurityConsts.USER, sec.getPermissions())); } if(null != entity.getClientPerms()) { SimpleSecurity.Builder sec = new SimpleSecurity.Builder(); sec.setClientRequired(true); sec.setPermissions(getReadScope(entity.getClientPerms(), type)); secs.add(sec.build()); seqs.add(new MApiSecurityReq(SecurityConsts.CLIENT, sec.getPermissions())); } if(!secs.isEmpty()) { route.setSecurities(secs.toArray(new SimpleSecurity[0])); } if(!seqs.isEmpty()) { route.setExtension(MApiSecurityReq[].class, seqs.toArray(new MApiSecurityReq[0])); } } }
protected boolean setDefaultLocation(RouteBuilder route, MApiParameterBuilder p) { if(null == p.getLocation()) { if (route.getPathTemplate().getTemplateVariables().contains(p.getName())) { p.setLocation(MApiParameter.Location.PATH); return true; } if(p.getType().isComplexType() || p.getType().isTypeRef() || p.getType().isDictionaryType()) { p.setLocation(MApiParameter.Location.BODY); return true; } p.setLocation(MApiParameter.Location.QUERY); return true; } return false; }
private void processHandlerMethod(RouteBuilder route, HandlerMethod hm) { if(!RequestMappingHandlerAdapterEx.enabled) { return; } if(hm.getMethodParameters().length == 0) { return; } HandlerMethodMapping mapping = new HandlerMethodMapping(); for(MethodParameter p : hm.getMethodParameters()) { String name = getParameterName(p); if(null == name) { continue; } Argument a = getArgument(route.getAction(), name); if(null != a) { mapping.params.put(name, a); } } if(mapping.params.isEmpty()) { return; } if(null == ResolverCompositeWrapper.validationManager) { ResolverCompositeWrapper.validationManager = validationManager; } RequestMappingHandlerAdapterEx.mappings.put(hm.getMethod(), mapping); }
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("GET", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addArgument(context, action, CountOptions.class, "options"); if (null != callback) { callback.postAddArguments(action); } addModelCountResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if(isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
static void withPermsForWrite(RestdModel model, RouteBuilder route, String type) { MetaEntity entity = (MetaEntity)model.getAttribute(MetaEntity.class.getName()); if(null != entity) { route.setExtension(entity); route.setAllowAnonymous(entity.getAnonymous()); List<SimpleSecurity> secs = new ArrayList<>(); List<MApiSecurityReq> seqs = new ArrayList<>(); if(null != entity.getUserPerms()) { SimpleSecurity.Builder sec = new SimpleSecurity.Builder(); sec.setUserRequired(true); sec.setPermissions(getWriteScope(entity.getUserPerms(), type)); secs.add(sec.build()); seqs.add(new MApiSecurityReq(SecurityConsts.USER, sec.getPermissions())); } if(null != entity.getClientPerms()) { SimpleSecurity.Builder sec = new SimpleSecurity.Builder(); sec.setClientRequired(true); sec.setPermissions(getWriteScope(entity.getClientPerms(), type)); secs.add(sec.build()); seqs.add(new MApiSecurityReq(SecurityConsts.CLIENT, sec.getPermissions())); } if(!secs.isEmpty()) { route.setSecurities(secs.toArray(new SimpleSecurity[0])); } if(!seqs.isEmpty()) { route.setExtension(MApiSecurityReq[].class, seqs.toArray(new MApiSecurityReq[0])); } } }
protected boolean doCheckOperationExists(RestdContext context, RouteBuilder r, Routes routes, boolean container) { final String verb = r.getMethod(); final String path = r.getPathTemplate().getTemplate(); final String fullPath = container ? path : Paths.suffixWithSlash(context.getApi().getBasePath()) + Paths.prefixWithoutSlash(path); Action combinedAction = new CombinedAction(action, r.getAction()); r.setAction(combinedAction); r.setEnabled(true);
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("PATCH", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addIdArguments(context, action, model); addModelArgumentForUpdate(context, action, model); if (null != callback) { callback.postAddArguments(action); } addNoContentResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("POST", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addModelArgumentForCreate(context, action, model); if (null != callback) { callback.postAddArguments(action); } addModelResponse(action, model).setStatus(201); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("DELETE", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addIdArguments(context, action, model); addOtherArguments(c, context, action, model); if (null != callback) { callback.postAddArguments(action); } addNoContentResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model, String path, String name, Callback callback) { FuncActionBuilder action = new FuncActionBuilder(name); RouteBuilder route = rm.createRoute("GET", path); if (null != callback) { callback.preAddArguments(action); } action.setFunction(createFunction(context, model, action.getArguments().size())); addIdArguments(context, action, model); addArgument(context, action, QueryOptionsBase.class, "options"); if (null != callback) { callback.postAddArguments(action); } addModelResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
@Override public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model) { if (!context.getConfig().allowModelOperation(model.getName(), NAME)) { return; } String verb = "PUT"; String path = fullModelPath(c, model) + getIdPath(model); FuncActionBuilder action = new FuncActionBuilder(); RouteBuilder route = rm.createRoute(verb, path); action.setName(Strings.lowerCamel(NAME, model.getName())); action.setFunction(createFunction(context, model, action.getArguments().size())); addIdArguments(context, action, model); addModelArgumentForReplace(context, action, model); addNoContentResponse(action, model); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
@Override public void createCrudOperation(ApiConfigurator c, RestdContext context, RestdModel model) { if (!context.getConfig().allowModelOperation(model.getName(), NAME)) { return; } String verb = "POST"; String path = fullModelPath(c, model) + "/" + NAME; RouteBuilder route = rm.createRoute(verb, path); if (isOperationExists(context, route)) { return; } FuncActionBuilder action = new FuncActionBuilder(); action.setName(Strings.lowerCamel(NAME, model.getName())); action.setFunction(new CalculateFunction(context.getApi(), context.getDao(), model)); addTypeArgument(context, action); addModelArgument(context, action, model); addModelResponse(action, model).setStatus(200); preConfigure(context, model, action); route.setAction(action.build()); setCrudOperation(route, NAME); postConfigure(context, model, route); if (isOperationExists(context, route)) { return; } c.addDynamicRoute(rm.loadRoute(context.getRoutes(), route)); }
route.setAction(action.build()); postConfigure(ctx, model, route, mo);