Java Validate类代码示例

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "save", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "key", failureCode = 2),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "key", failureCode = 3),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "name", failureCode = 4),
        @Validate(validator = Validators.NOT_EMPTY, parameter = "appId", failureCode = 5),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "appId", failureCode = 6),
        @Validate(validator = Validators.NOT_EMPTY, parameter = "secret", failureCode = 7),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "secret", failureCode = 8),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "token", failureCode = 9),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "mchId", failureCode = 10),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "mchKey", failureCode = 11),
        @Validate(validator = Validators.SIGN, string = {"ranch-weixin"}),
        @Validate(validator = WeixinService.VALIDATOR_NOT_EXISTS, parameters = {"key", "appId"}, failureCode = 12)

})
public Object save() {
    return weixinService.save(request.setToModel(new WeixinModel()));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "read", type = Templates.FREEMARKER, template = "read", validates = {
        @Validate(validator = Validators.ID, parameter = "id", failureCode = 11),
        @Validate(validator = DocService.VALIDATOR_EXISTS, parameter = "id", failureCode = 12)
})
public Object read() {
    Map<String, Object> map = new HashMap<>();
    boolean html = "true".equals(request.get("html"));
    map.put("html", html);
    if (html) {
        map.put("model", docService.findById(request.get("id")));
        map.put("css", request.getAsArray("css"));
    }
    map.put("content", docService.read(request.get("id")));

    return map;
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "debug/.+", type = Templates.STRING, validates = {
        @Validate(validator = ScriptValidator.NAME, parameter = "parameter", string = {"validator1", "validator2"})
})
public Object debugScript() {
    response.setContentType("text/javascript");
    String uri = request.getUri();

    return engine.read(uri.substring(uri.lastIndexOf('/')));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "find-sign", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "idUidCode", failureCode = 31),
        @Validate(validator = Validators.SIGN)
})
public Object findOrSign() {
    return userService.findOrSign(request.get("idUidCode"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "query", validates = {
        @Validate(validator = Validators.MOBILE, emptyable = true, parameter = "mobile", failureCode = 9),
        @Validate(validator = Validators.SIGN)
})
public Object query() {
    return userService.query(request.get("mobile"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
/**
 * 认证用户信息。
 * appId 微信App ID。
 * code 微信认证码。
 *
 * @return 微信用户信息，如果认证失败则返回空JSON。
 */
@Execute(name = "auth", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "appId", failureCode = 1),
        @Validate(validator = Validators.NOT_EMPTY, parameter = "code", failureCode = 2)
})
public Object auth() {
    return templates.get().success(weixinService.auth(request.get("appId"), request.get("code")), null);
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
/**
 * 获取JS SDK签名。
 * appId 微信公众号AppID。
 * url 请求URL地址。
 *
 * @return {timestamp:"",nonceStr:"",signature:""}。
 */
@Execute(name = "jsapi-sign", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "appId", failureCode = 1),
        @Validate(validator = Validators.NOT_EMPTY, parameter = "url", failureCode = 3)
})
public Object jsapiSign() {
    return weixinHelper.getJsApiSign(request.get("appId"), request.get("url"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "find", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "user", failureCode = 1),
        @Validate(validator = UserHelper.VALIDATOR_SIGN_IN),
        @Validate(validator = UserHelper.VALIDATOR_EXISTS, parameter = "user")
})
public Object find() {
    return modelHelper.toJson(friendService.find(request.get("user")));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "profit", validates = {
        @Validate(validator = Validators.MAX_LENGTH, number = {36}, parameter = "owner", failureCode = 1),
        @Validate(validator = Validators.BETWEEN, number = {0, 9}, parameter = "type", failureCode = 2),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "channel", failureCode = 3),
        @Validate(validator = Validators.GREATER_THAN, number = {0}, parameter = "amount", failureCode = 4),
        @Validate(validator = UserHelper.VALIDATOR_EXISTS_OR_SIGN_IN, parameter = "user", failureCode = 5)
})
public Object profit() {
    return execute(accountService.profit(request.get("user"), request.get("owner"), request.getAsInt("type"),
            request.get("channel"), request.getAsLong("amount")), 14, "profit");
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "query", validates = {
        @Validate(validator = Validators.SIGN)
})
public Object query() {
    String state = request.get("state");
    if (validator.isEmpty(state))
        state = "-1";

    return transferService.query(request.get("type"), request.get("appId"), request.get("user"), request.get("orderNo"),
            request.get("billNo"), request.get("tradeNo"), numeric.toInt(state), request.get("start"), request.get("end"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "send", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "key", failureCode = 2),
        @Validate(validator = Validators.NOT_EMPTY, parameter = "receiver", failureCode = 10),
        @Validate(validator = Validators.SIGN),
        @Validate(validator = PushService.VALIDATOR_EXISTS_KEY, parameter = "key", failureCode = 11)
})
public Object send() {
    return pushService.send(request.get("key"), request.get("receiver"), request.getAsJsonObject("args"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "remit-in", validates = {
        @Validate(validator = Validators.MAX_LENGTH, number = {36}, parameter = "owner", failureCode = 1),
        @Validate(validator = Validators.BETWEEN, number = {0, 9}, parameter = "type", failureCode = 2),
        @Validate(validator = Validators.MAX_LENGTH, number = {100}, parameter = "channel", failureCode = 3),
        @Validate(validator = Validators.GREATER_THAN, number = {0}, parameter = "amount", failureCode = 4),
        @Validate(validator = UserHelper.VALIDATOR_EXISTS_OR_SIGN_IN, parameter = "user", failureCode = 5)
})
public Object remitIn() {
    return execute(accountService.remitIn(request.get("user"), request.get("owner"), request.getAsInt("type"),
            request.get("channel"), request.getAsLong("amount")), 16, "remit-in");
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "reject", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "ids", failureCode = 21),
        @Validate(validator = Validators.SIGN)
})
public Object reject() {
    return logService.reject(request.getAsArray("ids"));
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "state", validates = {
        @Validate(validator = Validators.ID, parameter = "id", failureCode = 22),
        @Validate(validator = Validators.BETWEEN, number = {0, 1}, parameter = "state", failureCode = 24),
        @Validate(validator = Validators.SIGN),
        @Validate(validator = UserService.VALIDATOR_EXISTS, parameter = "id", failureCode = 25)
})
public Object state() {
    userService.state(request.get("id"), request.getAsInt("state"));

    return "";
}
 

import org.lpw.tephra.ctrl.validate.Validate; //导入依赖的package包/类
@Execute(name = "get", validates = {
        @Validate(validator = Validators.NOT_EMPTY, parameter = "ids", failureCode = 1),
        @Validate(validator = Validators.SIGN)
})
public Object get() {
    return snapshotService.get(request.getAsArray("ids"));
}