/**
* Builds the full URI path to this resource method.
*
* @return the full URI path to this resource method.
*/
public String getFullpath() {
List<String> subpaths = new ArrayList<String>();
if (getSubpath() != null) {
subpaths.add(0, getSubpath());
}
Resource parent = getParent();
while (parent != null) {
subpaths.add(0, parent.getPath());
parent = parent.getParent();
}
StringBuilder builder = new StringBuilder();
for (String subpath : subpaths) {
subpath = subpath.trim();
if (!subpath.startsWith("/")) {
subpath = '/' + subpath;
}
while (subpath.endsWith("/")) {
subpath = subpath.substring(0, subpath.length() - 1);
}
subpath = scrubParamNames(subpath);
builder.append(subpath);
}
return builder.toString();
}
protected String toIteratedStringExpression(JParameter arg) {
StringBuilder result = new StringBuilder();
result
.append("new org.fusesource.restygwt.client.StringIterable (")
.append(arg.getName())
.append(")");
return result.toString();
}
private String getFileName(CourseComponent component) {
StringBuilder sb = new StringBuilder();
sb.append(component.getPresentationId().replaceAll(" ", "_"));
if (null != component.getWhen()) {
sb.append("_");
sb.append(component.getWhen().replaceAll(" ", "_"));
}
return sb.toString();
}
private String buildString(Collection<String> collection) {
StringBuilder sb = new StringBuilder();
if (!collection.isEmpty()) {
for (String s : collection) {
sb.append(s).append('/');
}
}
return sb.toString();
}
/**
* The servlet pattern that can be applied to access this resource method.
*
* @return The servlet pattern that can be applied to access this resource method.
*/
public String getServletPattern() {
StringBuilder builder = new StringBuilder();
String fullPath = getFullpath();
Matcher pathParamMatcher = CONTEXT_PARAM_PATTERN.matcher(fullPath);
if (pathParamMatcher.find()) {
builder.append(fullPath, 0, pathParamMatcher.start()).append("*");
} else {
builder.append(fullPath);
}
return builder.toString();
}
@Override
protected ClassSourceFileComposerFactory createComposerFactory() {
String parameters = "";
if (source instanceof JGenericType) {
JGenericType gtype = (JGenericType) source;
StringBuilder builder = new StringBuilder();
builder.append("<");
boolean first = true;
for (JTypeParameter arg : gtype.getTypeParameters()) {
if (!first) builder.append(",");
builder.append(arg.getName());
builder.append(" extends ");
builder.append(arg.getFirstBound().getParameterizedQualifiedSourceName());
first = false;
}
builder.append(">");
parameters = builder.toString();
}
ClassSourceFileComposerFactory composerFactory =
new ClassSourceFileComposerFactory(packageName, shortName + parameters);
composerFactory.addImplementedInterface(source.getParameterizedQualifiedSourceName());
composerFactory.addImplementedInterface(RestServiceProxy.class.getName());
return composerFactory;
}
@PUT
@Path("subscribed/")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.TEXT_PLAIN)
public String subscribeTrees(String repXml) {
PlistParser parser = new PlistParser();
List<SubscribedTreeModel> list = (List<SubscribedTreeModel>) parser.parse(repXml);
List<Long> result = EJBLocator.getStampServiceBean().subscribeTrees(list);
StringBuilder sb = new StringBuilder();
for (Long l : result) {
sb.append(String.valueOf(l));
sb.append(CAMMA);
}
String pks = sb.substring(0, sb.length() - 1);
debug(pks);
return pks;
}
public static String makeClientEtag(
final PwmApplication pwmApplication,
final PwmSession pwmSession,
final HttpServletRequest httpServletRequest)
throws PwmUnrecoverableException {
final StringBuilder inputString = new StringBuilder();
inputString.append(PwmConstants.BUILD_NUMBER);
inputString.append(pwmApplication.getStartupTime().getTime());
inputString.append(httpServletRequest.getSession().getMaxInactiveInterval());
inputString.append(pwmApplication.getInstanceNonce());
if (pwmSession.getSessionStateBean().getLocale() != null) {
inputString.append(pwmSession.getSessionStateBean().getLocale());
}
inputString.append(pwmSession.getSessionStateBean().getSessionID());
if (pwmSession.isAuthenticated()) {
inputString.append(pwmSession.getUserInfoBean().getUserGuid());
inputString.append(pwmSession.getLoginInfoBean().getAuthTime());
}
return SecureEngine.hash(inputString.toString(), PwmHashAlgorithm.SHA1).toLowerCase();
}
/**
* Scrubs the path parameters names from the specified subpath.
*
* @param subpath The subpath.
* @return The scrubbed path.
*/
protected static String scrubParamNames(String subpath) {
StringBuilder builder = new StringBuilder(subpath.length());
int charIndex = 0;
int inBrace = 0;
boolean definingRegexp = false;
while (charIndex < subpath.length()) {
char ch = subpath.charAt(charIndex++);
if (ch == '{') {
inBrace++;
} else if (ch == '}') {
inBrace--;
if (inBrace == 0) {
definingRegexp = false;
}
} else if (inBrace == 1 && ch == ':') {
definingRegexp = true;
}
if (!definingRegexp) {
builder.append(ch);
}
}
return builder.toString();
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("REQUEST FROM:");
builder.append(remoteAddress);
builder.append("\nPARAMS:\n");
Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> next = iterator.next();
final String key = next.getKey();
builder.append(key);
builder.append('=');
if (key.equalsIgnoreCase("DATA")) {
builder.append("\n\n");
}
builder.append(next.getValue());
if (iterator.hasNext()) {
builder.append('\n');
}
}
return builder.toString();
}
private void writeMethodImpl(JMethod method) throws UnableToCompleteException {
boolean returnRequest = false;
if (method.getReturnType() != JPrimitiveType.VOID) {
if (!method.getReturnType().getQualifiedSourceName().equals(Request.class.getName())
&& !method
.getReturnType()
.getQualifiedSourceName()
.equals(JsonpRequest.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. Method must have void, Request or JsonpRequest return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
} else {
returnRequest = true;
}
}
Json jsonAnnotation = source.getAnnotation(Json.class);
final Style classStyle = jsonAnnotation != null ? jsonAnnotation.style() : Style.DEFAULT;
Options classOptions = source.getAnnotation(Options.class);
Options options = method.getAnnotation(Options.class);
p(method.getReadableDeclaration(false, false, false, false, true) + " {").i(1);
{
String restMethod = getRestMethod(method);
LinkedList<JParameter> args =
new LinkedList<JParameter>(Arrays.asList(method.getParameters()));
// the last arg should be the callback.
if (args.isEmpty()) {
getLogger()
.log(
ERROR,
"Invalid rest method. Method must declare at least a callback argument: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
JParameter callbackArg = args.removeLast();
JClassType callbackType = callbackArg.getType().isClassOrInterface();
JClassType methodCallbackType = METHOD_CALLBACK_TYPE;
if (callbackType == null || !callbackType.isAssignableTo(methodCallbackType)) {
getLogger()
.log(
ERROR,
"Invalid rest method. Last argument must be a "
+ methodCallbackType.getName()
+ " type: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
JClassType resultType = getCallbackTypeGenericClass(callbackType);
String pathExpression = null;
Path pathAnnotation = method.getAnnotation(Path.class);
if (pathAnnotation != null) {
pathExpression = wrap(pathAnnotation.value());
}
JParameter contentArg = null;
HashMap<String, JParameter> queryParams = new HashMap<String, JParameter>();
HashMap<String, JParameter> formParams = new HashMap<String, JParameter>();
HashMap<String, JParameter> headerParams = new HashMap<String, JParameter>();
for (JParameter arg : args) {
PathParam paramPath = arg.getAnnotation(PathParam.class);
if (paramPath != null) {
if (pathExpression == null) {
getLogger()
.log(
ERROR,
"Invalid rest method. Invalid @PathParam annotation. Method is missing the @Path annotation: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
pathExpression = pathExpression(pathExpression, arg, paramPath);
// .replaceAll(Pattern.quote("{" + paramPath.value() + "}"),
// "\"+com.google.gwt.http.client.URL.encodePathSegment(" + toStringExpression(arg) +
// ")+\"");
if (arg.getAnnotation(Attribute.class) != null) {
// allow part of the arg-object participate in as PathParam and the object goes over the
// wire
contentArg = arg;
}
continue;
}
QueryParam queryParam = arg.getAnnotation(QueryParam.class);
if (queryParam != null) {
queryParams.put(queryParam.value(), arg);
continue;
}
FormParam formParam = arg.getAnnotation(FormParam.class);
if (formParam != null) {
formParams.put(formParam.value(), arg);
continue;
}
HeaderParam headerParam = arg.getAnnotation(HeaderParam.class);
if (headerParam != null) {
headerParams.put(headerParam.value(), arg);
continue;
}
if (!formParams.isEmpty()) {
getLogger()
.log(
ERROR,
"You can not have both @FormParam parameters and a content parameter: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
if (contentArg != null) {
getLogger()
.log(
ERROR,
"Invalid rest method. Only one content parameter is supported: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
contentArg = arg;
}
String acceptTypeBuiltIn = null;
if (callbackType.equals(TEXT_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_TEXT";
} else if (callbackType.equals(JSON_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_JSON";
} else if (callbackType.isAssignableTo(OVERLAY_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_JSON";
} else if (callbackType.equals(XML_CALLBACK_TYPE)) {
acceptTypeBuiltIn = "CONTENT_TYPE_XML";
}
p("final " + METHOD_CLASS + " __method =");
p("getResource()");
if (pathExpression != null) {
p(".resolve(" + pathExpression + ")");
}
for (Map.Entry<String, JParameter> entry : queryParams.entrySet()) {
String expr = entry.getValue().getName();
JClassType type = entry.getValue().getType().isClassOrInterface();
if (type != null && isQueryParamListType(type)) {
p(
".addQueryParams("
+ wrap(entry.getKey())
+ ", "
+ toIteratedStringExpression(entry.getValue())
+ ")");
} else {
p(
".addQueryParam("
+ wrap(entry.getKey())
+ ", "
+ toStringExpression(entry.getValue().getType(), expr)
+ ")");
}
}
// example: .get()
p("." + restMethod + "();");
// Handle JSONP specific configuration...
JSONP jsonpAnnotation = method.getAnnotation(JSONP.class);
final boolean isJsonp = restMethod.equals(METHOD_JSONP) && jsonpAnnotation != null;
if (isJsonp) {
if (returnRequest
&& !method
.getReturnType()
.getQualifiedSourceName()
.equals(JsonpRequest.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. JSONP method must have void or JsonpRequest return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
if (jsonpAnnotation.callbackParam().length() > 0) {
p(
"(("
+ JSONP_METHOD_CLASS
+ ")__method).callbackParam("
+ wrap(jsonpAnnotation.callbackParam())
+ ");");
}
if (jsonpAnnotation.failureCallbackParam().length() > 0) {
p(
"(("
+ JSONP_METHOD_CLASS
+ ")__method).failureCallbackParam("
+ wrap(jsonpAnnotation.failureCallbackParam())
+ ");");
}
} else {
if (returnRequest
&& !method.getReturnType().getQualifiedSourceName().equals(Request.class.getName())) {
getLogger()
.log(
ERROR,
"Invalid rest method. Non JSONP method must have void or Request return types: "
+ method.getReadableDeclaration());
throw new UnableToCompleteException();
}
}
// configure the dispatcher
if (options != null && options.dispatcher() != Dispatcher.class) {
// use the dispatcher configured for the method.
p("__method.setDispatcher(" + options.dispatcher().getName() + ".INSTANCE);");
} else {
// use the default dispatcher configured for the service..
p("__method.setDispatcher(this.dispatcher);");
}
// configure the expected statuses..
if (options != null && options.expect().length != 0) {
// Using method level defined expected status
p("__method.expect(" + join(options.expect(), ", ") + ");");
} else if (classOptions != null && classOptions.expect().length != 0) {
// Using class level defined expected status
p("__method.expect(" + join(classOptions.expect(), ", ") + ");");
}
// configure the timeout
if (options != null && options.timeout() >= 0) {
// Using method level defined value
p("__method.timeout(" + options.timeout() + ");");
} else if (classOptions != null && classOptions.timeout() >= 0) {
// Using class level defined value
p("__method.timeout(" + classOptions.timeout() + ");");
}
if (jsonpAnnotation == null) {
Produces producesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Produces.class);
if (producesAnnotation != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ wrap(producesAnnotation.value()[0])
+ ");");
} else {
// set the default accept header....
if (acceptTypeBuiltIn != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ RESOURCE_CLASS
+ "."
+ acceptTypeBuiltIn
+ ");");
} else {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_ACCEPT, "
+ RESOURCE_CLASS
+ ".CONTENT_TYPE_JSON);");
}
}
Consumes consumesAnnotation = findAnnotationOnMethodOrEnclosingType(method, Consumes.class);
if (consumesAnnotation != null) {
p(
"__method.header("
+ RESOURCE_CLASS
+ ".HEADER_CONTENT_TYPE, "
+ wrap(consumesAnnotation.value()[0])
+ ");");
}
// and set the explicit headers now (could override the accept header)
for (Map.Entry<String, JParameter> entry : headerParams.entrySet()) {
String expr = entry.getValue().getName();
p(
"__method.header("
+ wrap(entry.getKey())
+ ", "
+ toStringExpression(entry.getValue().getType(), expr)
+ ");");
}
}
if (!formParams.isEmpty()) {
p(FORM_POST_CONTENT_CLASS + " __formPostContent = new " + FORM_POST_CONTENT_CLASS + "();");
for (Map.Entry<String, JParameter> entry : formParams.entrySet()) {
p(
"__formPostContent.addParameter("
+ wrap(entry.getKey())
+ ", "
+ toFormStringExpression(entry.getValue(), classStyle)
+ ");");
}
p("__method.form(__formPostContent.getTextContent());");
}
if (contentArg != null) {
if (contentArg.getType() == STRING_TYPE) {
p("__method.text(" + contentArg.getName() + ");");
} else if (contentArg.getType() == JSON_VALUE_TYPE) {
p("__method.json(" + contentArg.getName() + ");");
} else if (contentArg.getType().isClass() != null
&& isOverlayArrayType(contentArg.getType().isClass())) {
p("__method.json(new " + JSON_ARRAY_CLASS + "(" + contentArg.getName() + "));");
} else if (contentArg.getType().isClass() != null
&& contentArg.getType().isClass().isAssignableTo(OVERLAY_VALUE_TYPE)) {
p("__method.json(new " + JSON_OBJECT_CLASS + "(" + contentArg.getName() + "));");
} else if (contentArg.getType() == DOCUMENT_TYPE) {
p("__method.xml(" + contentArg.getName() + ");");
} else {
JClassType contentClass = contentArg.getType().isClass();
if (contentClass == null) {
contentClass = contentArg.getType().isClassOrInterface();
if (!locator.isCollectionType(contentClass)) {
getLogger().log(ERROR, "Content argument must be a class.");
throw new UnableToCompleteException();
}
}
jsonAnnotation = contentArg.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
// example:
// .json(Listings$_Generated_JsonEncoder_$.INSTANCE.encode(arg0)
// )
p(
"__method.json("
+ locator.encodeExpression(contentClass, contentArg.getName(), style)
+ ");");
}
}
List<AnnotationResolver> annotationResolvers = getAnnotationResolvers(context, getLogger());
getLogger()
.log(
TreeLogger.DEBUG,
"found " + annotationResolvers.size() + " additional AnnotationResolvers");
for (AnnotationResolver a : annotationResolvers) {
getLogger()
.log(
TreeLogger.DEBUG,
"("
+ a.getClass().getName()
+ ") resolve `"
+ source.getName()
+ "#"
+ method.getName()
+ "´ ...");
final Map<String, String[]> addDataParams =
a.resolveAnnotation(getLogger(), source, method, restMethod);
if (addDataParams != null) {
for (String s : addDataParams.keySet()) {
final StringBuilder sb = new StringBuilder();
final List<String> classList = Arrays.asList(addDataParams.get(s));
sb.append("[");
for (int i = 0; i < classList.size(); ++i) {
sb.append("\\\"").append(classList.get(i)).append("\\\"");
if ((i + 1) < classList.size()) {
sb.append(",");
}
}
sb.append("]");
getLogger()
.log(TreeLogger.DEBUG, "add call with (\"" + s + "\", \"" + sb.toString() + "\")");
p("__method.addData(\"" + s + "\", \"" + sb.toString() + "\");");
}
}
}
if (acceptTypeBuiltIn != null) {
// TODO: shouldn't we also have a cach in here?
p(returnRequest(returnRequest, isJsonp) + "__method.send(" + callbackArg.getName() + ");");
} else if (isJsonp) {
p(returnRequest(returnRequest, isJsonp)
+ "(("
+ JSONP_METHOD_CLASS
+ ")__method).send(new "
+ ABSTRACT_ASYNC_CALLBACK_CLASS
+ "<"
+ resultType.getParameterizedQualifiedSourceName()
+ ">(("
+ JSONP_METHOD_CLASS
+ ")__method, "
+ callbackArg.getName()
+ ") {")
.i(1);
{
p("protected "
+ resultType.getParameterizedQualifiedSourceName()
+ " parseResult("
+ JSON_VALUE_CLASS
+ " result) throws Exception {")
.i(1);
{
if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) {
p("return (java.lang.Void) null;");
} else {
p("try {").i(1);
{
if (resultType.isAssignableTo(locator.LIST_TYPE)) {
p("result = new " + JSON_ARRAY_CLASS + "(result.getJavaScriptObject());");
}
jsonAnnotation = method.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
p("return " + locator.decodeExpression(resultType, "result", style) + ";");
}
i(-1).p("} catch (Throwable __e) {").i(1);
{
p(
"throw new "
+ RESPONSE_FORMAT_EXCEPTION_CLASS
+ "(\"Response was NOT a valid JSON document\", __e);");
}
i(-1).p("}");
}
}
i(-1).p("}");
}
i(-1).p("});");
} else {
p("try {").i(1);
{
p(returnRequest(returnRequest, isJsonp)
+ "__method.send(new "
+ ABSTRACT_REQUEST_CALLBACK_CLASS
+ "<"
+ resultType.getParameterizedQualifiedSourceName()
+ ">(__method, "
+ callbackArg.getName()
+ ") {")
.i(1);
{
p("protected "
+ resultType.getParameterizedQualifiedSourceName()
+ " parseResult() throws Exception {")
.i(1);
{
if (resultType.getParameterizedQualifiedSourceName().equals("java.lang.Void")) {
p("return (java.lang.Void) null;");
} else {
p("try {").i(1);
{
jsonAnnotation = method.getAnnotation(Json.class);
Style style = jsonAnnotation != null ? jsonAnnotation.style() : classStyle;
p(
"return "
+ locator.decodeExpression(
resultType,
JSON_PARSER_CLASS + ".parse(__method.getResponse().getText())",
style)
+ ";");
}
i(-1).p("} catch (Throwable __e) {").i(1);
{
p(
"throw new "
+ RESPONSE_FORMAT_EXCEPTION_CLASS
+ "(\"Response was NOT a valid JSON document\", __e);");
}
i(-1).p("}");
}
}
i(-1).p("}");
}
i(-1).p("});");
}
i(-1).p("} catch (" + REQUEST_EXCEPTION_CLASS + " __e) {").i(1);
{
p(callbackArg.getName() + ".onFailure(__method,__e);");
if (returnRequest) {
p("return null;");
}
}
i(-1).p("}");
}
}
i(-1).p("}");
}
public static void main(String[] args) throws Exception {
StringBuilder sb = new StringBuilder();
sb.append("insert into popedom (id, id_parent, code, name, menu, idx");
for (int i = 0; i < ACTIONS; i++) {
sb.append(",action" + i);
sb.append(",action" + i + "_name");
}
sb.append(") values (?, null, ?, ?, true, ?");
for (int i = 0; i < ACTIONS; i++) {
sb.append(",?");
sb.append(",?");
}
sb.append(")");
Class.forName("org.postgresql.Driver");
Connection conn = null;
try {
conn =
DriverManager.getConnection(
"jdbc:postgresql://192.168.2.250:5432/child", "postgres", "1234");
conn.createStatement().executeUpdate("delete from popedom ");
PreparedStatement ps = conn.prepareStatement(sb.toString());
WinkApplication wa = new WinkApplication();
int i = 0;
for (Class c : wa.getClasses()) {
Path path = (Path) c.getAnnotation(Path.class);
ps.setLong(1, i + 1);
ps.setString(2, path.value());
if (c.isAnnotationPresent(Description.class)) {
Description description = (Description) c.getAnnotation(Description.class);
ps.setString(3, description.value());
} else {
ps.setString(3, path.value());
}
ps.setLong(4, i + 1);
System.out.println(path.value());
Map<String, String> methodMap = new TreeMap<String, String>();
for (Method method : c.getDeclaredMethods()) {
String code = null;
if (method.isAnnotationPresent(GET.class)) {
code = "GET";
} else if (method.isAnnotationPresent(POST.class)) {
code = "POST";
} else if (method.isAnnotationPresent(PUT.class)) {
code = "PUT";
} else if (method.isAnnotationPresent(DELETE.class)) {
code = "DELETE";
} else {
continue;
}
boolean isAnn = method.isAnnotationPresent(Path.class);
if (isAnn) {
code += " " + method.getAnnotation(Path.class).value();
}
String name = null;
if (method.isAnnotationPresent(Description.class)) {
Description description = method.getAnnotation(Description.class);
name = description.value();
} else {
name = code;
}
methodMap.put(code, name);
}
int j = 0;
for (Map.Entry<String, String> entry : methodMap.entrySet()) {
ps.setString(5 + j * 2, entry.getKey());
ps.setString(5 + j * 2 + 1, entry.getValue());
j++;
}
for (int k = j; k < ACTIONS; k++) {
ps.setString(5 + k * 2, null);
ps.setString(5 + k * 2 + 1, null);
}
ps.executeUpdate();
i++;
}
ps.close();
} finally {
try {
conn.close();
} finally {
conn = null;
}
}
}