proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
j-easy_easy-rules
|
easy-rules/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java
|
DefaultRulesEngine
|
check
|
class DefaultRulesEngine extends AbstractRulesEngine {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultRulesEngine.class);
/**
* Create a new {@link DefaultRulesEngine} with default parameters.
*/
public DefaultRulesEngine() {
super();
}
/**
* Create a new {@link DefaultRulesEngine}.
*
* @param parameters of the engine
*/
public DefaultRulesEngine(final RulesEngineParameters parameters) {
super(parameters);
}
@Override
public void fire(Rules rules, Facts facts) {
Objects.requireNonNull(rules, "Rules must not be null");
Objects.requireNonNull(facts, "Facts must not be null");
triggerListenersBeforeRules(rules, facts);
doFire(rules, facts);
triggerListenersAfterRules(rules, facts);
}
void doFire(Rules rules, Facts facts) {
if (rules.isEmpty()) {
LOGGER.warn("No rules registered! Nothing to apply");
return;
}
logEngineParameters();
log(rules);
log(facts);
LOGGER.debug("Rules evaluation started");
for (Rule rule : rules) {
final String name = rule.getName();
final int priority = rule.getPriority();
if (priority > parameters.getPriorityThreshold()) {
LOGGER.debug("Rule priority threshold ({}) exceeded at rule '{}' with priority={}, next rules will be skipped",
parameters.getPriorityThreshold(), name, priority);
break;
}
if (!shouldBeEvaluated(rule, facts)) {
LOGGER.debug("Rule '{}' has been skipped before being evaluated", name);
continue;
}
boolean evaluationResult = false;
try {
evaluationResult = rule.evaluate(facts);
} catch (RuntimeException exception) {
LOGGER.error("Rule '" + name + "' evaluated with error", exception);
triggerListenersOnEvaluationError(rule, facts, exception);
// give the option to either skip next rules on evaluation error or continue by considering the evaluation error as false
if (parameters.isSkipOnFirstNonTriggeredRule()) {
LOGGER.debug("Next rules will be skipped since parameter skipOnFirstNonTriggeredRule is set");
break;
}
}
if (evaluationResult) {
LOGGER.debug("Rule '{}' triggered", name);
triggerListenersAfterEvaluate(rule, facts, true);
try {
triggerListenersBeforeExecute(rule, facts);
rule.execute(facts);
LOGGER.debug("Rule '{}' performed successfully", name);
triggerListenersOnSuccess(rule, facts);
if (parameters.isSkipOnFirstAppliedRule()) {
LOGGER.debug("Next rules will be skipped since parameter skipOnFirstAppliedRule is set");
break;
}
} catch (Exception exception) {
LOGGER.error("Rule '" + name + "' performed with error", exception);
triggerListenersOnFailure(rule, exception, facts);
if (parameters.isSkipOnFirstFailedRule()) {
LOGGER.debug("Next rules will be skipped since parameter skipOnFirstFailedRule is set");
break;
}
}
} else {
LOGGER.debug("Rule '{}' has been evaluated to false, it has not been executed", name);
triggerListenersAfterEvaluate(rule, facts, false);
if (parameters.isSkipOnFirstNonTriggeredRule()) {
LOGGER.debug("Next rules will be skipped since parameter skipOnFirstNonTriggeredRule is set");
break;
}
}
}
}
private void logEngineParameters() {
LOGGER.debug("{}", parameters);
}
private void log(Rules rules) {
LOGGER.debug("Registered rules:");
for (Rule rule : rules) {
LOGGER.debug("Rule { name = '{}', description = '{}', priority = '{}'}",
rule.getName(), rule.getDescription(), rule.getPriority());
}
}
private void log(Facts facts) {
LOGGER.debug("Known facts:");
for (Fact<?> fact : facts) {
LOGGER.debug("{}", fact);
}
}
@Override
public Map<Rule, Boolean> check(Rules rules, Facts facts) {<FILL_FUNCTION_BODY>}
private Map<Rule, Boolean> doCheck(Rules rules, Facts facts) {
LOGGER.debug("Checking rules");
Map<Rule, Boolean> result = new HashMap<>();
for (Rule rule : rules) {
if (shouldBeEvaluated(rule, facts)) {
result.put(rule, rule.evaluate(facts));
}
}
return result;
}
private void triggerListenersOnFailure(final Rule rule, final Exception exception, Facts facts) {
ruleListeners.forEach(ruleListener -> ruleListener.onFailure(rule, facts, exception));
}
private void triggerListenersOnSuccess(final Rule rule, Facts facts) {
ruleListeners.forEach(ruleListener -> ruleListener.onSuccess(rule, facts));
}
private void triggerListenersBeforeExecute(final Rule rule, Facts facts) {
ruleListeners.forEach(ruleListener -> ruleListener.beforeExecute(rule, facts));
}
private boolean triggerListenersBeforeEvaluate(Rule rule, Facts facts) {
return ruleListeners.stream().allMatch(ruleListener -> ruleListener.beforeEvaluate(rule, facts));
}
private void triggerListenersAfterEvaluate(Rule rule, Facts facts, boolean evaluationResult) {
ruleListeners.forEach(ruleListener -> ruleListener.afterEvaluate(rule, facts, evaluationResult));
}
private void triggerListenersOnEvaluationError(Rule rule, Facts facts, Exception exception) {
ruleListeners.forEach(ruleListener -> ruleListener.onEvaluationError(rule, facts, exception));
}
private void triggerListenersBeforeRules(Rules rule, Facts facts) {
rulesEngineListeners.forEach(rulesEngineListener -> rulesEngineListener.beforeEvaluate(rule, facts));
}
private void triggerListenersAfterRules(Rules rule, Facts facts) {
rulesEngineListeners.forEach(rulesEngineListener -> rulesEngineListener.afterExecute(rule, facts));
}
private boolean shouldBeEvaluated(Rule rule, Facts facts) {
return triggerListenersBeforeEvaluate(rule, facts);
}
}
|
Objects.requireNonNull(rules, "Rules must not be null");
Objects.requireNonNull(facts, "Facts must not be null");
triggerListenersBeforeRules(rules, facts);
Map<Rule, Boolean> result = doCheck(rules, facts);
triggerListenersAfterRules(rules, facts);
return result;
| 1,668
| 90
| 1,758
|
<methods>public org.jeasy.rules.api.RulesEngineParameters getParameters() ,public List<org.jeasy.rules.api.RuleListener> getRuleListeners() ,public List<org.jeasy.rules.api.RulesEngineListener> getRulesEngineListeners() ,public void registerRuleListener(org.jeasy.rules.api.RuleListener) ,public void registerRuleListeners(List<org.jeasy.rules.api.RuleListener>) ,public void registerRulesEngineListener(org.jeasy.rules.api.RulesEngineListener) ,public void registerRulesEngineListeners(List<org.jeasy.rules.api.RulesEngineListener>) <variables>org.jeasy.rules.api.RulesEngineParameters parameters,List<org.jeasy.rules.api.RuleListener> ruleListeners,List<org.jeasy.rules.api.RulesEngineListener> rulesEngineListeners
|
j-easy_easy-rules
|
easy-rules/easy-rules-core/src/main/java/org/jeasy/rules/core/InferenceRulesEngine.java
|
InferenceRulesEngine
|
fire
|
class InferenceRulesEngine extends AbstractRulesEngine {
private static final Logger LOGGER = LoggerFactory.getLogger(InferenceRulesEngine.class);
private final DefaultRulesEngine delegate;
/**
* Create a new inference rules engine with default parameters.
*/
public InferenceRulesEngine() {
this(new RulesEngineParameters());
}
/**
* Create a new inference rules engine.
*
* @param parameters of the engine
*/
public InferenceRulesEngine(RulesEngineParameters parameters) {
super(parameters);
delegate = new DefaultRulesEngine(parameters);
}
@Override
public void fire(Rules rules, Facts facts) {<FILL_FUNCTION_BODY>}
private Set<Rule> selectCandidates(Rules rules, Facts facts) {
Set<Rule> candidates = new TreeSet<>();
for (Rule rule : rules) {
if (rule.evaluate(facts)) {
candidates.add(rule);
}
}
return candidates;
}
@Override
public Map<Rule, Boolean> check(Rules rules, Facts facts) {
Objects.requireNonNull(rules, "Rules must not be null");
Objects.requireNonNull(facts, "Facts must not be null");
return delegate.check(rules, facts);
}
/**
* Register a rule listener.
* @param ruleListener to register
*/
public void registerRuleListener(RuleListener ruleListener) {
super.registerRuleListener(ruleListener);
delegate.registerRuleListener(ruleListener);
}
/**
* Register a list of rule listener.
* @param ruleListeners to register
*/
public void registerRuleListeners(List<RuleListener> ruleListeners) {
super.registerRuleListeners(ruleListeners);
delegate.registerRuleListeners(ruleListeners);
}
/**
* Register a rules engine listener.
* @param rulesEngineListener to register
*/
public void registerRulesEngineListener(RulesEngineListener rulesEngineListener) {
super.registerRulesEngineListener(rulesEngineListener);
delegate.registerRulesEngineListener(rulesEngineListener);
}
/**
* Register a list of rules engine listener.
* @param rulesEngineListeners to register
*/
public void registerRulesEngineListeners(List<RulesEngineListener> rulesEngineListeners) {
super.registerRulesEngineListeners(rulesEngineListeners);
delegate.registerRulesEngineListeners(rulesEngineListeners);
}
}
|
Objects.requireNonNull(rules, "Rules must not be null");
Objects.requireNonNull(facts, "Facts must not be null");
Set<Rule> selectedRules;
do {
LOGGER.debug("Selecting candidate rules based on the following facts: {}", facts);
selectedRules = selectCandidates(rules, facts);
if (!selectedRules.isEmpty()) {
delegate.fire(new Rules(selectedRules), facts);
} else {
LOGGER.debug("No candidate rules found for facts: {}", facts);
}
} while (!selectedRules.isEmpty());
| 652
| 155
| 807
|
<methods>public org.jeasy.rules.api.RulesEngineParameters getParameters() ,public List<org.jeasy.rules.api.RuleListener> getRuleListeners() ,public List<org.jeasy.rules.api.RulesEngineListener> getRulesEngineListeners() ,public void registerRuleListener(org.jeasy.rules.api.RuleListener) ,public void registerRuleListeners(List<org.jeasy.rules.api.RuleListener>) ,public void registerRulesEngineListener(org.jeasy.rules.api.RulesEngineListener) ,public void registerRulesEngineListeners(List<org.jeasy.rules.api.RulesEngineListener>) <variables>org.jeasy.rules.api.RulesEngineParameters parameters,List<org.jeasy.rules.api.RuleListener> ruleListeners,List<org.jeasy.rules.api.RulesEngineListener> rulesEngineListeners
|
j-easy_easy-rules
|
easy-rules/easy-rules-core/src/main/java/org/jeasy/rules/core/RuleDefinitionValidator.java
|
RuleDefinitionValidator
|
checkConditionMethod
|
class RuleDefinitionValidator {
void validateRuleDefinition(final Object rule) {
checkRuleClass(rule);
checkConditionMethod(rule);
checkActionMethods(rule);
checkPriorityMethod(rule);
}
private void checkRuleClass(final Object rule) {
if (!isRuleClassWellDefined(rule)) {
throw new IllegalArgumentException(format("Rule '%s' is not annotated with '%s'", rule.getClass().getName(), Rule.class.getName()));
}
}
private void checkConditionMethod(final Object rule) {<FILL_FUNCTION_BODY>}
private void checkActionMethods(final Object rule) {
List<Method> actionMethods = getMethodsAnnotatedWith(Action.class, rule);
if (actionMethods.isEmpty()) {
throw new IllegalArgumentException(format("Rule '%s' must have at least one public method annotated with '%s'", rule.getClass().getName(), Action.class.getName()));
}
for (Method actionMethod : actionMethods) {
if (!isActionMethodWellDefined(actionMethod)) {
throw new IllegalArgumentException(format("Action method '%s' defined in rule '%s' must be public, must return void type and may have parameters annotated with @Fact (and/or exactly one parameter of type Facts or one of its sub-types).", actionMethod, rule.getClass().getName()));
}
}
}
private void checkPriorityMethod(final Object rule) {
List<Method> priorityMethods = getMethodsAnnotatedWith(Priority.class, rule);
if (priorityMethods.isEmpty()) {
return;
}
if (priorityMethods.size() > 1) {
throw new IllegalArgumentException(format("Rule '%s' must have exactly one method annotated with '%s'", rule.getClass().getName(), Priority.class.getName()));
}
Method priorityMethod = priorityMethods.get(0);
if (!isPriorityMethodWellDefined(priorityMethod)) {
throw new IllegalArgumentException(format("Priority method '%s' defined in rule '%s' must be public, have no parameters and return integer type.", priorityMethod, rule.getClass().getName()));
}
}
private boolean isRuleClassWellDefined(final Object rule) {
return Utils.isAnnotationPresent(Rule.class, rule.getClass());
}
private boolean isConditionMethodWellDefined(final Method method) {
return Modifier.isPublic(method.getModifiers())
&& method.getReturnType().equals(Boolean.TYPE)
&& validParameters(method);
}
private boolean validParameters(final Method method) {
int notAnnotatedParameterCount = 0;
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
for (Annotation[] annotations : parameterAnnotations) {
if (annotations.length == 0) {
notAnnotatedParameterCount += 1;
} else {
//Annotation types has to be Fact
for (Annotation annotation : annotations) {
if (!annotation.annotationType().equals(Fact.class)) {
return false;
}
}
}
}
if (notAnnotatedParameterCount > 1) {
return false;
}
if (notAnnotatedParameterCount == 1) {
Parameter notAnnotatedParameter = getNotAnnotatedParameter(method);
if (notAnnotatedParameter != null) {
return Facts.class.isAssignableFrom(notAnnotatedParameter.getType());
}
}
return true;
}
private Parameter getNotAnnotatedParameter(Method method) {
Parameter[] parameters = method.getParameters();
for (Parameter parameter : parameters) {
if (parameter.getAnnotations().length == 0) {
return parameter;
}
}
return null;
}
private boolean isActionMethodWellDefined(final Method method) {
return Modifier.isPublic(method.getModifiers())
&& method.getReturnType().equals(Void.TYPE)
&& validParameters(method);
}
private boolean isPriorityMethodWellDefined(final Method method) {
return Modifier.isPublic(method.getModifiers())
&& method.getReturnType().equals(Integer.TYPE)
&& method.getParameterTypes().length == 0;
}
private List<Method> getMethodsAnnotatedWith(final Class<? extends Annotation> annotation, final Object rule) {
Method[] methods = getMethods(rule);
List<Method> annotatedMethods = new ArrayList<>();
for (Method method : methods) {
if (method.isAnnotationPresent(annotation)) {
annotatedMethods.add(method);
}
}
return annotatedMethods;
}
private Method[] getMethods(final Object rule) {
return rule.getClass().getMethods();
}
}
|
List<Method> conditionMethods = getMethodsAnnotatedWith(Condition.class, rule);
if (conditionMethods.isEmpty()) {
throw new IllegalArgumentException(format("Rule '%s' must have a public method annotated with '%s'", rule.getClass().getName(), Condition.class.getName()));
}
if (conditionMethods.size() > 1) {
throw new IllegalArgumentException(format("Rule '%s' must have exactly one method annotated with '%s'", rule.getClass().getName(), Condition.class.getName()));
}
Method conditionMethod = conditionMethods.get(0);
if (!isConditionMethodWellDefined(conditionMethod)) {
throw new IllegalArgumentException(format("Condition method '%s' defined in rule '%s' must be public, must return boolean type and may have parameters annotated with @Fact (and/or exactly one parameter of type Facts or one of its sub-types).", conditionMethod, rule.getClass().getName()));
}
| 1,204
| 231
| 1,435
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-core/src/main/java/org/jeasy/rules/core/Utils.java
|
Utils
|
findAnnotation
|
class Utils {
private Utils() { }
static <A extends Annotation> A findAnnotation(final Class<A> targetAnnotation, final Class<?> annotatedType) {<FILL_FUNCTION_BODY>}
static boolean isAnnotationPresent(final Class<? extends Annotation> targetAnnotation, final Class<?> annotatedType) {
return findAnnotation(targetAnnotation, annotatedType) != null;
}
}
|
A foundAnnotation = annotatedType.getAnnotation(targetAnnotation);
if (foundAnnotation == null) {
for (Annotation annotation : annotatedType.getAnnotations()) {
Class<? extends Annotation> annotationType = annotation.annotationType();
if (annotationType.isAnnotationPresent(targetAnnotation)) {
foundAnnotation = annotationType.getAnnotation(targetAnnotation);
break;
}
}
}
return foundAnnotation;
| 111
| 110
| 221
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-jexl/src/main/java/org/jeasy/rules/jexl/JexlAction.java
|
JexlAction
|
execute
|
class JexlAction implements Action {
private static final Logger LOGGER = LoggerFactory.getLogger(JexlAction.class);
private final JexlScript compiledScript;
private final String expression;
public JexlAction(String expression) {
this.expression = Objects.requireNonNull(expression, "expression cannot be null");
this.compiledScript = JexlRule.DEFAULT_JEXL.createScript(expression);
}
public JexlAction(String expression, JexlEngine jexl) {
this.expression = Objects.requireNonNull(expression, "expression cannot be null");
Objects.requireNonNull(jexl, "jexl cannot be null");
this.compiledScript = jexl.createScript(expression);
}
@Override
public void execute(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
Objects.requireNonNull(facts, "facts cannot be null");
MapContext ctx = new MapContext(facts.asMap());
try {
compiledScript.execute(ctx);
} catch (JexlException e) {
LOGGER.error("Unable to execute expression: '" + expression + "' on facts: " + facts, e);
throw e;
}
| 227
| 98
| 325
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-jexl/src/main/java/org/jeasy/rules/jexl/JexlCondition.java
|
JexlCondition
|
evaluate
|
class JexlCondition implements Condition {
private final JexlScript compiledScript;
public JexlCondition(String expression) {
Objects.requireNonNull(expression, "expression cannot be null");
this.compiledScript = JexlRule.DEFAULT_JEXL.createScript(expression);
}
public JexlCondition(String expression, JexlEngine jexl) {
Objects.requireNonNull(expression, "expression cannot be null");
Objects.requireNonNull(jexl, "jexl cannot be null");
this.compiledScript = jexl.createScript(expression);
}
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
Objects.requireNonNull(facts, "facts cannot be null");
MapContext ctx = new MapContext(facts.asMap());
return (Boolean) compiledScript.execute(ctx);
| 187
| 51
| 238
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-jexl/src/main/java/org/jeasy/rules/jexl/JexlRule.java
|
JexlRule
|
then
|
class JexlRule extends BasicRule {
static final JexlEngine DEFAULT_JEXL = new JexlBuilder().create();
private Condition condition = Condition.FALSE;
private final List<Action> actions = new ArrayList<>();
private final JexlEngine jexl;
public JexlRule() {
this(DEFAULT_JEXL);
}
public JexlRule(JexlEngine jexl) {
super(Rule.DEFAULT_NAME, Rule.DEFAULT_DESCRIPTION, Rule.DEFAULT_PRIORITY);
this.jexl = Objects.requireNonNull(jexl, "jexl cannot be null");
}
public JexlRule name(String name) {
this.name = Objects.requireNonNull(name, "name cannot be null");
return this;
}
public JexlRule description(String description) {
this.description = Objects.requireNonNull(description, "description cannot be null");
return this;
}
public JexlRule priority(int priority) {
this.priority = priority;
return this;
}
public JexlRule when(String condition) {
Objects.requireNonNull(condition, "condition cannot be null");
this.condition = new JexlCondition(condition, jexl);
return this;
}
public JexlRule then(String action) {<FILL_FUNCTION_BODY>}
@Override
public boolean evaluate(Facts facts) {
Objects.requireNonNull(facts, "facts cannot be null");
return condition.evaluate(facts);
}
@Override
public void execute(Facts facts) throws Exception {
Objects.requireNonNull(facts, "facts cannot be null");
for (Action action : actions) {
action.execute(facts);
}
}
}
|
Objects.requireNonNull(action, "action cannot be null");
this.actions.add(new JexlAction(action, jexl));
return this;
| 481
| 45
| 526
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, int) ,public int compareTo(org.jeasy.rules.api.Rule) ,public boolean equals(java.lang.Object) ,public boolean evaluate(org.jeasy.rules.api.Facts) ,public void execute(org.jeasy.rules.api.Facts) throws java.lang.Exception,public java.lang.String getDescription() ,public java.lang.String getName() ,public int getPriority() ,public int hashCode() ,public void setDescription(java.lang.String) ,public void setPriority(int) ,public java.lang.String toString() <variables>protected java.lang.String description,protected java.lang.String name,protected int priority
|
j-easy_easy-rules
|
easy-rules/easy-rules-jexl/src/main/java/org/jeasy/rules/jexl/JexlRuleFactory.java
|
JexlRuleFactory
|
createRule
|
class JexlRuleFactory extends AbstractRuleFactory {
private final RuleDefinitionReader reader;
private final JexlEngine jexl;
public JexlRuleFactory(RuleDefinitionReader reader) {
this(reader, JexlRule.DEFAULT_JEXL);
}
public JexlRuleFactory(RuleDefinitionReader reader, JexlEngine jexl) {
this.reader = Objects.requireNonNull(reader, "reader cannot be null");
this.jexl = Objects.requireNonNull(jexl, "Jexl Engine cannot be null");
}
public Rule createRule(Reader ruleDescriptor) throws Exception {<FILL_FUNCTION_BODY>}
public Rules createRules(Reader rulesDescriptor) throws Exception {
Objects.requireNonNull(rulesDescriptor, "rulesDescriptor cannot be null");
Rules rules = new Rules();
List<RuleDefinition> ruleDefinitions = reader.read(rulesDescriptor);
for (RuleDefinition ruleDefinition : ruleDefinitions) {
rules.register(createRule(ruleDefinition));
}
return rules;
}
@Override
protected Rule createSimpleRule(RuleDefinition ruleDefinition) {
Objects.requireNonNull(ruleDefinition, "ruleDefinition cannot be null");
JexlRule rule = new JexlRule(jexl)
.name(ruleDefinition.getName())
.description(ruleDefinition.getDescription())
.priority(ruleDefinition.getPriority())
.when(ruleDefinition.getCondition());
for (String action : ruleDefinition.getActions()) {
rule.then(action);
}
return rule;
}
}
|
Objects.requireNonNull(ruleDescriptor, "ruleDescriptor cannot be null");
Objects.requireNonNull(jexl, "jexl cannot be null");
List<RuleDefinition> ruleDefinitions = reader.read(ruleDescriptor);
if (ruleDefinitions.isEmpty()) {
throw new IllegalArgumentException("rule descriptor is empty");
}
return createRule(ruleDefinitions.get(0));
| 408
| 104
| 512
|
<methods>public non-sealed void <init>() <variables>private static final List<java.lang.String> ALLOWED_COMPOSITE_RULE_TYPES,private static final Logger LOGGER
|
j-easy_easy-rules
|
easy-rules/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELAction.java
|
MVELAction
|
execute
|
class MVELAction implements Action {
private static final Logger LOGGER = LoggerFactory.getLogger(MVELAction.class);
private final String expression;
private final Serializable compiledExpression;
/**
* Create a new {@link MVELAction}.
*
* @param expression the action written in expression language
*/
public MVELAction(String expression) {
this.expression = expression;
compiledExpression = MVEL.compileExpression(expression);
}
/**
* Create a new {@link MVELAction}.
*
* @param expression the action written in expression language
* @param parserContext the MVEL parser context
*/
public MVELAction(String expression, ParserContext parserContext) {
this.expression = expression;
compiledExpression = MVEL.compileExpression(expression, parserContext);
}
@Override
public void execute(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
try {
MVEL.executeExpression(compiledExpression, facts.asMap());
} catch (Exception e) {
LOGGER.error("Unable to evaluate expression: '" + expression + "' on facts: " + facts, e);
throw e;
}
| 244
| 68
| 312
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELCondition.java
|
MVELCondition
|
evaluate
|
class MVELCondition implements Condition {
private final Serializable compiledExpression;
/**
* Create a new {@link MVELCondition}.
*
* @param expression the condition written in expression language
*/
public MVELCondition(String expression) {
compiledExpression = MVEL.compileExpression(expression);
}
/**
* Create a new {@link MVELCondition}.
*
* @param expression the condition written in expression language
* @param parserContext the MVEL parser context
*/
public MVELCondition(String expression, ParserContext parserContext) {
compiledExpression = MVEL.compileExpression(expression, parserContext);
}
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
// MVEL.evalToBoolean does not accept compiled expressions..
return (boolean) MVEL.executeExpression(compiledExpression, facts.asMap());
| 191
| 39
| 230
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-mvel/src/main/java/org/jeasy/rules/mvel/MVELRuleFactory.java
|
MVELRuleFactory
|
createSimpleRule
|
class MVELRuleFactory extends AbstractRuleFactory {
private final RuleDefinitionReader reader;
private final ParserContext parserContext;
/**
* Create a new {@link MVELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public MVELRuleFactory(RuleDefinitionReader reader) {
this(reader, new ParserContext());
}
/**
* Create a new {@link MVELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @param parserContext used to parse condition/action expressions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public MVELRuleFactory(RuleDefinitionReader reader, ParserContext parserContext) {
this.reader = reader;
this.parserContext = parserContext;
}
/**
* Create a new {@link MVELRule} from a Reader.
*
* The rule descriptor should contain a single rule definition.
* If no rule definitions are found, a {@link IllegalArgumentException} will be thrown.
* If more than a rule is defined in the descriptor, the first rule will be returned.
*
* @param ruleDescriptor descriptor of rule definition
* @return a new rule
* @throws Exception if unable to create the rule from the descriptor
*/
public Rule createRule(Reader ruleDescriptor) throws Exception {
List<RuleDefinition> ruleDefinitions = reader.read(ruleDescriptor);
if (ruleDefinitions.isEmpty()) {
throw new IllegalArgumentException("rule descriptor is empty");
}
return createRule(ruleDefinitions.get(0));
}
/**
* Create a set of {@link MVELRule} from a rule descriptor.
*
* @param rulesDescriptor descriptor of rule definitions
* @return a set of rules
* @throws Exception if unable to create rules from the descriptor
*/
public Rules createRules(Reader rulesDescriptor) throws Exception {
Rules rules = new Rules();
List<RuleDefinition> ruleDefinitions = reader.read(rulesDescriptor);
for (RuleDefinition ruleDefinition : ruleDefinitions) {
rules.register(createRule(ruleDefinition));
}
return rules;
}
protected Rule createSimpleRule(RuleDefinition ruleDefinition) {<FILL_FUNCTION_BODY>}
}
|
MVELRule mvelRule = new MVELRule(parserContext)
.name(ruleDefinition.getName())
.description(ruleDefinition.getDescription())
.priority(ruleDefinition.getPriority())
.when(ruleDefinition.getCondition());
for (String action : ruleDefinition.getActions()) {
mvelRule.then(action);
}
return mvelRule;
| 597
| 98
| 695
|
<methods>public non-sealed void <init>() <variables>private static final List<java.lang.String> ALLOWED_COMPOSITE_RULE_TYPES,private static final Logger LOGGER
|
j-easy_easy-rules
|
easy-rules/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELAction.java
|
SpELAction
|
execute
|
class SpELAction implements Action {
private static final Logger LOGGER = LoggerFactory.getLogger(SpELAction.class);
private final ExpressionParser parser = new SpelExpressionParser();
private final String expression;
private final Expression compiledExpression;
private BeanResolver beanResolver;
/**
* Create a new {@link SpELAction}.
*
* @param expression the action written in expression language
*/
public SpELAction(String expression) {
this(expression, ParserContext.TEMPLATE_EXPRESSION);
}
/**
* Create a new {@link SpELAction}.
*
* @param expression the action written in expression language
* @param beanResolver the bean resolver used to resolve bean references
*/
public SpELAction(String expression, BeanResolver beanResolver) {
this(expression, ParserContext.TEMPLATE_EXPRESSION, beanResolver);
}
/**
* Create a new {@link SpELAction}.
*
* @param expression the action written in expression language
* @param parserContext the SpEL parser context
*/
public SpELAction(String expression, ParserContext parserContext) {
this.expression = expression;
compiledExpression = parser.parseExpression(expression, parserContext);
}
/**
* Create a new {@link SpELAction}.
*
* @param expression the action written in expression language
* @param beanResolver the bean resolver used to resolve bean references
* @param parserContext the SpEL parser context
*/
public SpELAction(String expression, ParserContext parserContext, BeanResolver beanResolver) {
this.expression = expression;
this.beanResolver = beanResolver;
compiledExpression = parser.parseExpression(expression, parserContext);
}
@Override
public void execute(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
try {
StandardEvaluationContext context = new StandardEvaluationContext();
context.setRootObject(facts.asMap());
context.setVariables(facts.asMap());
if (beanResolver != null) {
context.setBeanResolver(beanResolver);
}
compiledExpression.getValue(context);
} catch (Exception e) {
LOGGER.error("Unable to evaluate expression: '" + expression + "' on facts: " + facts, e);
throw e;
}
| 486
| 127
| 613
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELCondition.java
|
SpELCondition
|
evaluate
|
class SpELCondition implements Condition {
private final ExpressionParser parser = new SpelExpressionParser();
private final Expression compiledExpression;
private BeanResolver beanResolver;
/**
* Create a new {@link SpELCondition}.
*
* @param expression the condition written in expression language
*/
public SpELCondition(String expression) {
this(expression, ParserContext.TEMPLATE_EXPRESSION);
}
/**
* Create a new {@link SpELCondition}.
*
* @param expression the condition written in expression language
* @param beanResolver the bean resolver used to resolve bean references
*/
public SpELCondition(String expression, BeanResolver beanResolver) {
this(expression, ParserContext.TEMPLATE_EXPRESSION, beanResolver);
}
/**
* Create a new {@link SpELCondition}.
*
* @param expression the condition written in expression language
* @param parserContext the SpEL parser context
*/
public SpELCondition(String expression, ParserContext parserContext) {
compiledExpression = parser.parseExpression(expression, parserContext);
}
/**
* Create a new {@link SpELCondition}.
*
* @param expression the condition written in expression language
* @param beanResolver the bean resolver used to resolve bean references
* @param parserContext the SpEL parser context
*/
public SpELCondition(String expression, ParserContext parserContext, BeanResolver beanResolver) {
this.beanResolver = beanResolver;
compiledExpression = parser.parseExpression(expression, parserContext);
}
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
StandardEvaluationContext context = new StandardEvaluationContext();
context.setRootObject(facts.asMap());
context.setVariables(facts.asMap());
if (beanResolver != null) {
context.setBeanResolver(beanResolver);
}
return compiledExpression.getValue(context, Boolean.class);
| 430
| 84
| 514
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-spel/src/main/java/org/jeasy/rules/spel/SpELRuleFactory.java
|
SpELRuleFactory
|
createRule
|
class SpELRuleFactory extends AbstractRuleFactory {
private final RuleDefinitionReader reader;
private BeanResolver beanResolver;
private ParserContext parserContext;
/**
* Create a new {@link SpELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public SpELRuleFactory(RuleDefinitionReader reader) {
this(reader, ParserContext.TEMPLATE_EXPRESSION);
}
/**
* Create a new {@link SpELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @param parserContext used to parse SpEL expressions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public SpELRuleFactory(RuleDefinitionReader reader, ParserContext parserContext) {
this.reader = reader;
this.parserContext = parserContext;
}
/**
* Create a new {@link SpELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @param beanResolver used to resolve bean references in SpEL expressions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public SpELRuleFactory(RuleDefinitionReader reader, BeanResolver beanResolver) {
this.reader = reader;
this.beanResolver = beanResolver;
}
/**
* Create a new {@link SpELRuleFactory} with a given reader.
*
* @param reader used to read rule definitions
* @param parserContext used to parse SpEL expressions
* @param beanResolver used to resolve bean references in SpEL expressions
* @see YamlRuleDefinitionReader
* @see JsonRuleDefinitionReader
*/
public SpELRuleFactory(RuleDefinitionReader reader, ParserContext parserContext, BeanResolver beanResolver) {
this.reader = reader;
this.parserContext = parserContext;
this.beanResolver = beanResolver;
}
/**
* Create a new {@link SpELRule} from a Reader.
*
* The rule descriptor should contain a single rule definition.
* If no rule definitions are found, a {@link IllegalArgumentException} will be thrown.
* If more than a rule is defined in the descriptor, the first rule will be returned.
*
* @param ruleDescriptor descriptor of rule definition
* @return a new rule
* @throws Exception if unable to create the rule from the descriptor
*/
public Rule createRule(Reader ruleDescriptor) throws Exception {<FILL_FUNCTION_BODY>}
/**
* Create a set of {@link SpELRule} from a Reader.
*
* @param rulesDescriptor descriptor of rule definitions
* @return a set of rules
* @throws Exception if unable to create rules from the descriptor
*/
public Rules createRules(Reader rulesDescriptor) throws Exception {
Rules rules = new Rules();
List<RuleDefinition> ruleDefinitions = reader.read(rulesDescriptor);
for (RuleDefinition ruleDefinition : ruleDefinitions) {
rules.register(createRule(ruleDefinition));
}
return rules;
}
protected Rule createSimpleRule(RuleDefinition ruleDefinition) {
SpELRule spELRule = new SpELRule(parserContext, beanResolver)
.name(ruleDefinition.getName())
.description(ruleDefinition.getDescription())
.priority(ruleDefinition.getPriority())
.when(ruleDefinition.getCondition());
for (String action : ruleDefinition.getActions()) {
spELRule.then(action);
}
return spELRule;
}
}
|
List<RuleDefinition> ruleDefinitions = reader.read(ruleDescriptor);
if (ruleDefinitions.isEmpty()) {
throw new IllegalArgumentException("rule descriptor is empty");
}
return createRule(ruleDefinitions.get(0));
| 908
| 64
| 972
|
<methods>public non-sealed void <init>() <variables>private static final List<java.lang.String> ALLOWED_COMPOSITE_RULE_TYPES,private static final Logger LOGGER
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/AbstractRuleFactory.java
|
AbstractRuleFactory
|
createCompositeRule
|
class AbstractRuleFactory {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractRuleFactory.class);
private static final List<String> ALLOWED_COMPOSITE_RULE_TYPES = Arrays.asList(
UnitRuleGroup.class.getSimpleName(),
ConditionalRuleGroup.class.getSimpleName(),
ActivationRuleGroup.class.getSimpleName()
);
protected Rule createRule(RuleDefinition ruleDefinition) {
if (ruleDefinition.isCompositeRule()) {
return createCompositeRule(ruleDefinition);
} else {
return createSimpleRule(ruleDefinition);
}
}
protected abstract Rule createSimpleRule(RuleDefinition ruleDefinition);
protected Rule createCompositeRule(RuleDefinition ruleDefinition) {<FILL_FUNCTION_BODY>}
}
|
if (ruleDefinition.getCondition() != null) {
LOGGER.warn(
"Condition '{}' in composite rule '{}' of type {} will be ignored.",
ruleDefinition.getCondition(),
ruleDefinition.getName(),
ruleDefinition.getCompositeRuleType());
}
if (ruleDefinition.getActions() != null && !ruleDefinition.getActions().isEmpty()) {
LOGGER.warn(
"Actions '{}' in composite rule '{}' of type {} will be ignored.",
ruleDefinition.getActions(),
ruleDefinition.getName(),
ruleDefinition.getCompositeRuleType());
}
CompositeRule compositeRule;
String name = ruleDefinition.getName();
switch (ruleDefinition.getCompositeRuleType()) {
case "UnitRuleGroup":
compositeRule = new UnitRuleGroup(name);
break;
case "ActivationRuleGroup":
compositeRule = new ActivationRuleGroup(name);
break;
case "ConditionalRuleGroup":
compositeRule = new ConditionalRuleGroup(name);
break;
default:
throw new IllegalArgumentException("Invalid composite rule type, must be one of " + ALLOWED_COMPOSITE_RULE_TYPES);
}
compositeRule.setDescription(ruleDefinition.getDescription());
compositeRule.setPriority(ruleDefinition.getPriority());
for (RuleDefinition composingRuleDefinition : ruleDefinition.getComposingRules()) {
compositeRule.addRule(createRule(composingRuleDefinition));
}
return compositeRule;
| 207
| 378
| 585
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/composite/ActivationRuleGroup.java
|
ActivationRuleGroup
|
evaluate
|
class ActivationRuleGroup extends CompositeRule {
private Rule selectedRule;
/**
* Create an activation rule group.
*/
public ActivationRuleGroup() {
rules = new TreeSet<>(rules);
}
/**
* Create an activation rule group.
*
* @param name of the activation rule group
*/
public ActivationRuleGroup(String name) {
super(name);
rules = new TreeSet<>(rules);
}
/**
* Create a conditional rule group.
*
* @param name of the activation rule group
* @param description of the activation rule group
*/
public ActivationRuleGroup(String name, String description) {
super(name, description);
rules = new TreeSet<>(rules);
}
/**
* Create an activation rule group.
*
* @param name of the activation rule group
* @param description of the activation rule group
* @param priority of the activation rule group
*/
public ActivationRuleGroup(String name, String description, int priority) {
super(name, description, priority);
rules = new TreeSet<>(rules);
}
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
@Override
public void execute(Facts facts) throws Exception {
if (selectedRule != null) {
selectedRule.execute(facts);
}
}
}
|
for (Rule rule : rules) {
if (rule.evaluate(facts)) {
selectedRule = rule;
return true;
}
}
return false;
| 370
| 49
| 419
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, int) ,public void addRule(java.lang.Object) ,public abstract boolean evaluate(org.jeasy.rules.api.Facts) ,public abstract void execute(org.jeasy.rules.api.Facts) throws java.lang.Exception,public void removeRule(java.lang.Object) <variables>private final non-sealed Map<java.lang.Object,org.jeasy.rules.api.Rule> proxyRules,protected Set<org.jeasy.rules.api.Rule> rules
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/composite/CompositeRule.java
|
CompositeRule
|
removeRule
|
class CompositeRule extends BasicRule {
/**
* The set of composing rules.
*/
protected Set<Rule> rules;
private final Map<Object, Rule> proxyRules;
/**
* Create a new {@link CompositeRule}.
*/
public CompositeRule() {
this(Rule.DEFAULT_NAME, Rule.DEFAULT_DESCRIPTION, Rule.DEFAULT_PRIORITY);
}
/**
* Create a new {@link CompositeRule}.
*
* @param name rule name
*/
public CompositeRule(final String name) {
this(name, Rule.DEFAULT_DESCRIPTION, Rule.DEFAULT_PRIORITY);
}
/**
* Create a new {@link CompositeRule}.
*
* @param name rule name
* @param description rule description
*/
public CompositeRule(final String name, final String description) {
this(name, description, Rule.DEFAULT_PRIORITY);
}
/**
* Create a new {@link CompositeRule}.
*
* @param name rule name
* @param description rule description
* @param priority rule priority
*/
public CompositeRule(final String name, final String description, final int priority) {
super(name, description, priority);
rules = new TreeSet<>();
proxyRules = new HashMap<>();
}
@Override
public abstract boolean evaluate(Facts facts);
@Override
public abstract void execute(Facts facts) throws Exception;
/**
* Add a rule to the composite rule.
* @param rule the rule to add
*/
public void addRule(final Object rule) {
Rule proxy = RuleProxy.asRule(rule);
rules.add(proxy);
proxyRules.put(rule, proxy);
}
/**
* Remove a rule from the composite rule.
* @param rule the rule to remove
*/
public void removeRule(final Object rule) {<FILL_FUNCTION_BODY>}
}
|
Rule proxy = proxyRules.get(rule);
if (proxy != null) {
rules.remove(proxy);
}
| 513
| 37
| 550
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, int) ,public int compareTo(org.jeasy.rules.api.Rule) ,public boolean equals(java.lang.Object) ,public boolean evaluate(org.jeasy.rules.api.Facts) ,public void execute(org.jeasy.rules.api.Facts) throws java.lang.Exception,public java.lang.String getDescription() ,public java.lang.String getName() ,public int getPriority() ,public int hashCode() ,public void setDescription(java.lang.String) ,public void setPriority(int) ,public java.lang.String toString() <variables>protected java.lang.String description,protected java.lang.String name,protected int priority
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/composite/ConditionalRuleGroup.java
|
ConditionalRuleGroup
|
evaluate
|
class ConditionalRuleGroup extends CompositeRule {
private Set<Rule> successfulEvaluations;
private Rule conditionalRule;
/**
* Create a conditional rule group.
*/
public ConditionalRuleGroup() {
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
*/
public ConditionalRuleGroup(String name) {
super(name);
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
* @param description of the conditional rule
*/
public ConditionalRuleGroup(String name, String description) {
super(name, description);
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
* @param description of the conditional rule
* @param priority of the composite rule
*/
public ConditionalRuleGroup(String name, String description, int priority) {
super(name, description, priority);
}
/**
* A conditional rule group will trigger all its composing rules if the condition
* of the rule with highest priority evaluates to true.
*
* @param facts The facts.
* @return true if the conditions of all composing rules evaluate to true
*/
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
/**
* When a conditional rule group is executed, all rules that evaluated to true
* are performed in their natural order, but with the conditional rule
* (the one with the highest priority) first.
*
* @param facts The facts.
*
* @throws Exception thrown if an exception occurs during actions performing
*/
@Override
public void execute(Facts facts) throws Exception {
conditionalRule.execute(facts);
for (Rule rule : sort(successfulEvaluations)) {
rule.execute(facts);
}
}
private Rule getRuleWithHighestPriority() {
List<Rule> copy = sort(rules);
// make sure we only have one rule with the highest priority
Rule highest = copy.get(0);
if (copy.size() > 1 && copy.get(1).getPriority() == highest.getPriority()) {
throw new IllegalArgumentException("Only one rule can have highest priority");
}
return highest;
}
private List<Rule> sort(Set<Rule> rules) {
return new ArrayList<>(new TreeSet<>(rules));
}
}
|
successfulEvaluations = new HashSet<>();
conditionalRule = getRuleWithHighestPriority();
if (conditionalRule.evaluate(facts)) {
for (Rule rule : rules) {
if (rule != conditionalRule && rule.evaluate(facts)) {
successfulEvaluations.add(rule);
}
}
return true;
}
return false;
| 633
| 102
| 735
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, int) ,public void addRule(java.lang.Object) ,public abstract boolean evaluate(org.jeasy.rules.api.Facts) ,public abstract void execute(org.jeasy.rules.api.Facts) throws java.lang.Exception,public void removeRule(java.lang.Object) <variables>private final non-sealed Map<java.lang.Object,org.jeasy.rules.api.Rule> proxyRules,protected Set<org.jeasy.rules.api.Rule> rules
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/composite/UnitRuleGroup.java
|
UnitRuleGroup
|
evaluate
|
class UnitRuleGroup extends CompositeRule {
/**
* Create a unit rule group.
*/
public UnitRuleGroup() {
}
/**
* Create a unit rule group.
* @param name of the composite rule
*/
public UnitRuleGroup(String name) {
super(name);
}
/**
* Create a unit rule group.
* @param name of the composite rule
* @param description of the composite rule
*/
public UnitRuleGroup(String name, String description) {
super(name, description);
}
/**
* Create a unit rule group.
* @param name of the composite rule
* @param description of the composite rule
* @param priority of the composite rule
*/
public UnitRuleGroup(String name, String description, int priority) {
super(name, description, priority);
}
@Override
public boolean evaluate(Facts facts) {<FILL_FUNCTION_BODY>}
@Override
public void execute(Facts facts) throws Exception {
for (Rule rule : rules) {
rule.execute(facts);
}
}
}
|
if (!rules.isEmpty()) {
for (Rule rule : rules) {
if (!rule.evaluate(facts)) {
return false;
}
}
return true;
}
return false;
| 293
| 59
| 352
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.String, int) ,public void addRule(java.lang.Object) ,public abstract boolean evaluate(org.jeasy.rules.api.Facts) ,public abstract void execute(org.jeasy.rules.api.Facts) throws java.lang.Exception,public void removeRule(java.lang.Object) <variables>private final non-sealed Map<java.lang.Object,org.jeasy.rules.api.Rule> proxyRules,protected Set<org.jeasy.rules.api.Rule> rules
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/reader/AbstractRuleDefinitionReader.java
|
AbstractRuleDefinitionReader
|
createRuleDefinition
|
class AbstractRuleDefinitionReader implements RuleDefinitionReader {
public List<RuleDefinition> read(Reader reader) throws Exception {
List<RuleDefinition> ruleDefinitions = new ArrayList<>();
Iterable<Map<String, Object>> rules = loadRules(reader);
for (Map<String, Object> rule : rules) {
ruleDefinitions.add(createRuleDefinition(rule));
}
return ruleDefinitions;
}
/**
* Load rules from the given reader as an iterable of Maps.
*
* @param reader to read rules from
* @return an iterable of rule Maps
* @throws Exception if unable to load rules
*/
protected abstract Iterable<Map<String, Object>> loadRules(Reader reader) throws Exception;
/**
* Create a rule definition.
*
* @param map of rule properties
* @return a rule definition
*/
protected RuleDefinition createRuleDefinition(Map<String, Object> map) {<FILL_FUNCTION_BODY>}
}
|
RuleDefinition ruleDefinition = new RuleDefinition();
String name = (String) map.get("name");
ruleDefinition.setName(name != null ? name : Rule.DEFAULT_NAME);
String description = (String) map.get("description");
ruleDefinition.setDescription(description != null ? description : Rule.DEFAULT_DESCRIPTION);
Integer priority = (Integer) map.get("priority");
ruleDefinition.setPriority(priority != null ? priority : Rule.DEFAULT_PRIORITY);
String compositeRuleType = (String) map.get("compositeRuleType");
String condition = (String) map.get("condition");
if (condition == null && compositeRuleType == null) {
throw new IllegalArgumentException("The rule condition must be specified");
}
ruleDefinition.setCondition(condition);
List<String> actions = (List<String>) map.get("actions");
if ((actions == null || actions.isEmpty()) && compositeRuleType == null) {
throw new IllegalArgumentException("The rule action(s) must be specified");
}
ruleDefinition.setActions(actions);
List<Object> composingRules = (List<Object>) map.get("composingRules");
if ((composingRules != null && !composingRules.isEmpty()) && compositeRuleType == null) {
throw new IllegalArgumentException("Non-composite rules cannot have composing rules");
} else if ((composingRules == null || composingRules.isEmpty()) && compositeRuleType != null) {
throw new IllegalArgumentException("Composite rules must have composing rules specified");
} else if (composingRules != null) {
List<RuleDefinition> composingRuleDefinitions = new ArrayList<>();
for (Object rule : composingRules) {
Map<String, Object> composingRuleMap = (Map<String, Object>) rule;
composingRuleDefinitions.add(createRuleDefinition(composingRuleMap));
}
ruleDefinition.setComposingRules(composingRuleDefinitions);
ruleDefinition.setCompositeRuleType(compositeRuleType);
}
return ruleDefinition;
| 257
| 532
| 789
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/reader/JsonRuleDefinitionReader.java
|
JsonRuleDefinitionReader
|
loadRules
|
class JsonRuleDefinitionReader extends AbstractRuleDefinitionReader {
private final ObjectMapper objectMapper;
/**
* Create a new {@link JsonRuleDefinitionReader}.
*/
public JsonRuleDefinitionReader() {
this(new ObjectMapper());
}
/**
* Create a new {@link JsonRuleDefinitionReader}.
*
* @param objectMapper to use to read rule definitions
*/
public JsonRuleDefinitionReader(ObjectMapper objectMapper) {
this.objectMapper = objectMapper;
}
@Override
protected Iterable<Map<String, Object>> loadRules(Reader reader) throws Exception {<FILL_FUNCTION_BODY>}
}
|
List<Map<String, Object>> rulesList = new ArrayList<>();
Object[] rules = objectMapper.readValue(reader, Object[].class);
for (Object rule : rules) {
rulesList.add((Map<String, Object>) rule);
}
return rulesList;
| 167
| 74
| 241
|
<methods>public non-sealed void <init>() ,public List<org.jeasy.rules.support.RuleDefinition> read(java.io.Reader) throws java.lang.Exception<variables>
|
j-easy_easy-rules
|
easy-rules/easy-rules-support/src/main/java/org/jeasy/rules/support/reader/YamlRuleDefinitionReader.java
|
YamlRuleDefinitionReader
|
loadRules
|
class YamlRuleDefinitionReader extends AbstractRuleDefinitionReader {
private final Yaml yaml;
/**
* Create a new {@link YamlRuleDefinitionReader}.
*/
public YamlRuleDefinitionReader() {
this(new Yaml());
}
/**
* Create a new {@link YamlRuleDefinitionReader}.
*
* @param yaml to use to read rule definitions
*/
public YamlRuleDefinitionReader(Yaml yaml) {
this.yaml = yaml;
}
@Override
protected Iterable<Map<String, Object>> loadRules(Reader reader) {<FILL_FUNCTION_BODY>}
}
|
List<Map<String, Object>> rulesList = new ArrayList<>();
Iterable<Object> rules = yaml.loadAll(reader);
for (Object rule : rules) {
rulesList.add((Map<String, Object>) rule);
}
return rulesList;
| 169
| 72
| 241
|
<methods>public non-sealed void <init>() ,public List<org.jeasy.rules.support.RuleDefinition> read(java.io.Reader) throws java.lang.Exception<variables>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/airco/DecreaseTemperatureAction.java
|
DecreaseTemperatureAction
|
execute
|
class DecreaseTemperatureAction implements Action {
static DecreaseTemperatureAction decreaseTemperature() {
return new DecreaseTemperatureAction();
}
@Override
public void execute(Facts facts) {<FILL_FUNCTION_BODY>}
}
|
System.out.println("It is hot! cooling air..");
Integer temperature = facts.get("temperature");
facts.put("temperature", temperature - 1);
| 70
| 43
| 113
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/airco/Launcher.java
|
Launcher
|
main
|
class Launcher {
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// define facts
Facts facts = new Facts();
facts.put("temperature", 30);
// define rules
Rule airConditioningRule = new RuleBuilder()
.name("air conditioning rule")
.when(itIsHot())
.then(decreaseTemperature())
.build();
Rules rules = new Rules();
rules.register(airConditioningRule);
// fire rules on known facts
RulesEngine rulesEngine = new InferenceRulesEngine();
rulesEngine.fire(rules, facts);
| 33
| 135
| 168
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzz.java
|
FizzBuzz
|
main
|
class FizzBuzz { // Everything in Java is a class
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// Every program must have main()
for (int i = 1; i <= 100; i++) { // count from 1 to 100
if (((i % 5) == 0) && ((i % 7) == 0)) // A multiple of both?
System.out.print("fizzbuzz");
else if ((i % 5) == 0) System.out.print("fizz"); // else a multiple of 5?
else if ((i % 7) == 0) System.out.print("buzz"); // else a multiple of 7?
else System.out.print(i); // else just print it
System.out.println();
}
System.out.println();
| 41
| 181
| 222
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzzWithEasyRules.java
|
FizzBuzzWithEasyRules
|
main
|
class FizzBuzzWithEasyRules {
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// create rules engine
RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);
// create rules
Rules rules = new Rules();
rules.register(new FizzRule());
rules.register(new BuzzRule());
rules.register(new FizzBuzzRule(new FizzRule(), new BuzzRule()));
rules.register(new NonFizzBuzzRule());
// fire rules
Facts facts = new Facts();
for (int i = 1; i <= 100; i++) {
facts.put("number", i);
fizzBuzzEngine.fire(rules, facts);
System.out.println();
}
| 38
| 191
| 229
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/NonFizzBuzzRule.java
|
NonFizzBuzzRule
|
isNotFizzNorBuzz
|
class NonFizzBuzzRule {
@Condition
public boolean isNotFizzNorBuzz(@Fact("number") Integer number) {<FILL_FUNCTION_BODY>}
@Action
public void printInput(@Fact("number") Integer number) {
System.out.print(number);
}
@Priority
public int getPriority() {
return 3;
}
}
|
// can return true, because this is the latest rule to trigger according to assigned priorities
// and in which case, the number is not fizz nor buzz
return number % 5 != 0 || number % 7 != 0;
| 103
| 58
| 161
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/helloworld/Launcher.java
|
Launcher
|
main
|
class Launcher {
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// create facts
Facts facts = new Facts();
// create rules
Rules rules = new Rules();
rules.register(new HelloWorldRule());
// create a rules engine and fire rules on known facts
RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, facts);
| 32
| 84
| 116
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/shop/Launcher.java
|
Launcher
|
main
|
class Launcher {
public static void main(String[] args) throws Exception {<FILL_FUNCTION_BODY>}
}
|
//create a person instance (fact)
Person tom = new Person("Tom", 14);
Facts facts = new Facts();
facts.put("person", tom);
// create rules
MVELRule ageRule = new MVELRule()
.name("age rule")
.description("Check if person's age is > 18 and mark the person as adult")
.priority(1)
.when("person.age > 18")
.then("person.setAdult(true);");
MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
String fileName = args.length != 0 ? args[0] : "easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/shop/alcohol-rule.yml";
Rule alcoholRule = ruleFactory.createRule(new FileReader(fileName));
// create a rule set
Rules rules = new Rules();
rules.register(ageRule);
rules.register(alcoholRule);
//create a default rules engine and fire rules on known facts
RulesEngine rulesEngine = new DefaultRulesEngine();
System.out.println("Tom: Hi! can I have some Vodka please?");
rulesEngine.fire(rules, facts);
| 35
| 323
| 358
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/shop/Person.java
|
Person
|
toString
|
class Person {
private String name;
private int age;
private boolean adult;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean isAdult() {
return adult;
}
public void setAdult(boolean adult) {
this.adult = adult;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", adult=" + adult +
'}';
| 160
| 45
| 205
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/weather/Launcher.java
|
Launcher
|
main
|
class Launcher {
public static void main(String[] args) {<FILL_FUNCTION_BODY>}
}
|
// define facts
Facts facts = new Facts();
facts.put("rain", true);
// define rules
WeatherRule weatherRule = new WeatherRule();
Rules rules = new Rules();
rules.register(weatherRule);
// fire rules on known facts
RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, facts);
| 33
| 97
| 130
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/IndexServlet.java
|
IndexServlet
|
doGet
|
class IndexServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {<FILL_FUNCTION_BODY>}
private boolean isSuspicious(HttpServletRequest request) {
return request.getAttribute(SUSPICIOUS) != null;
}
}
|
response.setContentType("text/plain");
PrintWriter out = response.getWriter();
if (isSuspicious(request)) {
out.print("Access denied\n");
} else {
out.print("Welcome!\n");
}
| 82
| 67
| 149
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestFilter.java
|
SuspiciousRequestFilter
|
init
|
class SuspiciousRequestFilter implements Filter {
private Rules rules;
private RulesEngine rulesEngine;
@Override
public void init(FilterConfig filterConfig) {<FILL_FUNCTION_BODY>}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
Facts facts = new Facts();
facts.put("request", request);
rulesEngine.fire(rules, facts);
filterChain.doFilter(request, response);
}
@Override
public void destroy() {
}
}
|
rulesEngine = new DefaultRulesEngine();
rules = new Rules();
rules.register(new SuspiciousRequestRule());
| 152
| 34
| 186
|
<no_super_class>
|
j-easy_easy-rules
|
easy-rules/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestRule.java
|
SuspiciousRequestRule
|
isSuspicious
|
class SuspiciousRequestRule {
static final String SUSPICIOUS = "suspicious";
@Condition
public boolean isSuspicious(@Fact("request") HttpServletRequest request) {<FILL_FUNCTION_BODY>}
@Action
public void setSuspicious(@Fact("request") HttpServletRequest request) {
request.setAttribute(SUSPICIOUS, true);
}
}
|
// criteria of suspicious could be based on ip, user-agent, etc.
// here for simplicity, it is based on the presence of a request parameter 'suspicious'
return request.getParameter(SUSPICIOUS) != null;
| 108
| 62
| 170
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/config/EruptNodeInterceptor.java
|
EruptNodeInterceptor
|
preHandle
|
class EruptNodeInterceptor implements WebMvcConfigurer, AsyncHandlerInterceptor {
@Resource
private EruptNodeProp eruptNodeProp;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(this).addPathPatterns(EruptRestPath.ERUPT_API + "/**");
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
MetaContext.remove();
}
}
|
if (!eruptNodeProp.getAccessToken().equals(request.getHeader(CloudCommonConst.HEADER_ACCESS_TOKEN))) {
throw new EruptWebApiRuntimeException("AccessToken incorrect");
}
MetaContext.registerToken(request.getHeader(EruptMutualConst.TOKEN));
Optional.ofNullable(request.getHeader(EruptMutualConst.USER)).ifPresent(it ->
MetaContext.register(GsonFactory.getGson().fromJson(Base64Decoder.decodeStr(it), MetaUser.class)));
MetaContext.register(new MetaErupt(request.getHeader(EruptMutualConst.ERUPT)));
//node节点管理的erupt类禁止浏览器直接访问
response.setHeader("Access-Control-Allow-Origin", "255.255.255.255");
return true;
| 175
| 227
| 402
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/config/EruptNodeProp.java
|
EruptNodeProp
|
getBalanceAddress
|
class EruptNodeProp {
public static final String SPACE = "erupt.cloud-node";
//是否开启NODE节点注册
private boolean enableRegister = true;
//是否开启附件上传代理，开启后上传能力全部交予server端实现【server端请求node端获取附件上传要求】
// private boolean attachmentProxy = true;
//接入应用名称，推荐填写当前 Java 项目名称
private String nodeName;
//客户端秘钥（在服务端界面生成）
private String accessToken;
//服务端地址（支持集群）
private String[] serverAddresses;
//自动注册时协议前缀
private String schema = "http";
/**
* 当前服务地址（支持集群，非必填）
* 正常情况下无需配置，多层代理等复杂网络环境下需配置此参数，目的是让server端准确寻址到node
*/
private String[] hostAddress;
//心跳时间(毫秒)
private int heartbeatTime = 15 * 1000;
private int count = 0;
public String getBalanceAddress() {<FILL_FUNCTION_BODY>}
}
|
if (this.serverAddresses.length == 1) {
return this.serverAddresses[0];
}
if (count >= Integer.MAX_VALUE) {
count = 0;
}
String address = this.serverAddresses[count++ % this.serverAddresses.length];
if (address.endsWith("/")) {
return address.substring(0, address.length() - 1);
}
return address;
| 315
| 113
| 428
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/interceptor/EruptCloutNodeInterceptor.java
|
EruptCloutNodeInterceptor
|
preHandle
|
class EruptCloutNodeInterceptor implements WebMvcConfigurer, AsyncHandlerInterceptor {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(this).addPathPatterns(EruptRestPath.ERUPT_API + "/**");
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {<FILL_FUNCTION_BODY>}
}
|
String erupt = request.getHeader(EruptMutualConst.ERUPT);
if (null != erupt) {
if (null == EruptCoreService.getErupt(erupt)) {
response.setStatus(HttpStatus.NOT_FOUND.value());
return false;
}
}
return true;
| 122
| 87
| 209
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/invoke/NodePowerInvoke.java
|
NodePowerInvoke
|
handler
|
class NodePowerInvoke implements PowerHandler {
static {
PowerInvoke.registerPowerHandler(NodePowerInvoke.class);
}
@Resource
private EruptNodeProp eruptNodeProp;
@Override
public void handler(PowerObject power) {<FILL_FUNCTION_BODY>}
}
|
EruptModel eruptModel = EruptCoreService.getErupt(MetaContext.getErupt().getName());
if (!eruptModel.getErupt().authVerify()) {
return;
}
String powerObjectString = HttpUtil.createGet(eruptNodeProp.getBalanceAddress() + CloudRestApiConst.ERUPT_POWER)
.form("nodeName", eruptNodeProp.getNodeName())
.form("eruptName", eruptModel.getEruptName())
.header(EruptMutualConst.TOKEN, MetaContext.getToken()).execute().body();
PowerObject remotePowerObject = GsonFactory.getGson().fromJson(powerObjectString, PowerObject.class);
if (power.isAdd()) {
power.setAdd(remotePowerObject.isAdd());
}
if (power.isDelete()) {
power.setDelete(remotePowerObject.isDelete());
}
if (power.isEdit()) {
power.setEdit(remotePowerObject.isEdit());
}
if (power.isViewDetails()) {
power.setViewDetails(remotePowerObject.isViewDetails());
}
if (power.isExport()) {
power.setExport(remotePowerObject.isExport());
}
if (power.isImportable()) {
power.setImportable(remotePowerObject.isImportable());
}
| 83
| 347
| 430
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/service/ServerRemoteService.java
|
ServerRemoteService
|
getRemoteUserInfo
|
class ServerRemoteService {
@Resource
private EruptNodeProp eruptNodeProp;
//校验菜单权限
public boolean getMenuCodePermission(String menuValue) {
String permissionResult =
HttpUtil.createGet(eruptNodeProp.getBalanceAddress() + EruptRestPath.ERUPT_CODE_PERMISSION + "/" + menuValue)
.header(EruptMutualConst.TOKEN, MetaContext.getToken()).execute().body();
return Boolean.parseBoolean(permissionResult);
}
public MetaUserinfo getRemoteUserInfo() {<FILL_FUNCTION_BODY>}
public String getNodeConfig() {
return HttpUtil.createGet(eruptNodeProp.getBalanceAddress() + CloudRestApiConst.NODE_CONFIG + "/" + eruptNodeProp.getNodeName())
.header(CloudCommonConst.HEADER_ACCESS_TOKEN, eruptNodeProp.getAccessToken())
.execute().body();
}
public String getNodeGroupConfig() {
return HttpUtil.createGet(eruptNodeProp.getBalanceAddress() + CloudRestApiConst.NODE_GROUP_CONFIG + "/" + eruptNodeProp.getNodeName())
.form(CloudCommonConst.HEADER_ACCESS_TOKEN, eruptNodeProp.getAccessToken())
.execute().body();
}
}
|
String userinfo = HttpUtil.createGet(eruptNodeProp.getBalanceAddress() + CloudRestApiConst.ERUPT_USER_INFO + eruptNodeProp.getNodeName())
.header(EruptMutualConst.TOKEN, MetaContext.getToken())
.header(CloudCommonConst.HEADER_ACCESS_TOKEN, eruptNodeProp.getAccessToken())
.execute().body();
return GsonFactory.getGson().fromJson(userinfo, MetaUserinfo.class);
| 344
| 129
| 473
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-node/src/main/java/xyz/erupt/cloud/node/task/EruptNodeTask.java
|
EruptNodeTask
|
run
|
class EruptNodeTask implements Runnable, ApplicationRunner, DisposableBean {
@Resource
private EruptNodeProp eruptNodeProp;
@Resource
private ServerProperties serverProperties;
private boolean runner = true;
private final Gson gson = GsonFactory.getGson();
private final String instanceId = RandomStringUtils.randomAlphabetic(6);
private boolean errorConnect = false;
private String hostName;
// public EruptNodeTask() {
// try {
// hostName = InetAddress.getLocalHost().getHostName();
// } catch (UnknownHostException ignore) {
// }
// }
@Override
public void run(ApplicationArguments args) {<FILL_FUNCTION_BODY>}
@SneakyThrows
@Override
public void run() {
if (null == eruptNodeProp.getServerAddresses() || eruptNodeProp.getServerAddresses().length <= 0) {
throw new RuntimeException(EruptNodeProp.SPACE + ".serverAddresses not config");
}
if (null == eruptNodeProp.getNodeName()) {
throw new RuntimeException(EruptNodeProp.SPACE + ".nodeName not config");
}
log.info("erupt-cloud-node initialization completed");
while (this.runner) {
NodeInfo nodeInfo = new NodeInfo();
nodeInfo.setInstanceId(instanceId);
nodeInfo.setNodeName(eruptNodeProp.getNodeName());
nodeInfo.setAccessToken(eruptNodeProp.getAccessToken());
nodeInfo.setVersion(EruptInformation.getEruptVersion());
nodeInfo.setEruptModules(EruptCoreService.getModules());
if (null != eruptNodeProp.getHostAddress() && eruptNodeProp.getHostAddress().length > 0) {
nodeInfo.setNodeAddress(eruptNodeProp.getHostAddress());
} else {
String contextPath = serverProperties.getServlet().getContextPath() == null ? "" : serverProperties.getServlet().getContextPath();
nodeInfo.setNodeAddress(new String[]{eruptNodeProp.getSchema() + "://" + Inet4Address.getLocalHost().getHostAddress() + ":" + serverProperties.getPort() + contextPath});
}
nodeInfo.setErupts(EruptCoreService.getErupts().stream().map(EruptModel::getEruptName).collect(Collectors.toList()));
String address = eruptNodeProp.getBalanceAddress();
try {
HttpResponse httpResponse = HttpUtil.createPost(address + CloudRestApiConst.REGISTER_NODE)
.body(gson.toJson(nodeInfo)).execute();
if (!httpResponse.isOk()) {
log.error(address + " -> Connection error: {}", httpResponse.body());
}
if (this.errorConnect) {
this.errorConnect = false;
log.info(address + " -> Connection success");
}
TimeUnit.MILLISECONDS.sleep(eruptNodeProp.getHeartbeatTime());
} catch (Exception e) {
log.error(address + " -> Connection error: {}", e.getMessage());
this.errorConnect = true;
TimeUnit.MILLISECONDS.sleep(eruptNodeProp.getHeartbeatTime() / 2);
}
}
}
@Override
public void destroy() {
this.runner = false;
// cancel register
HttpUtil.createPost(eruptNodeProp.getBalanceAddress() + CloudRestApiConst.REMOVE_INSTANCE_NODE
).form(new HashMap<String, Object>() {{
this.put("nodeName", eruptNodeProp.getNodeName());
this.put("accessToken", eruptNodeProp.getAccessToken());
}}).execute();
}
}
|
log.info(ansi().fg(Ansi.Color.BLUE) + " \n" +
" _ _ \n" +
" ___ ___ _ _ ___| |_ ___ ___ _| |___ \n" +
"| -_| _| | | . | _| | | . | . | -_|\n" +
"|___|_| |___| _|_| |_|_|___|___|___|\n" +
" |_| " + EruptInformation.getEruptVersion() + "\n" +
ansi().fg(Ansi.Color.DEFAULT)
);
if (eruptNodeProp.isEnableRegister()) {
Thread register = new Thread(this);
register.setName("erupt-node-register");
register.setDaemon(true);
register.start();
} else {
log.warn("erupt-node registration disabled");
}
| 965
| 241
| 1,206
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/EruptCloudServerAutoConfiguration.java
|
EruptCloudServerAutoConfiguration
|
initMenus
|
class EruptCloudServerAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptCloudServerAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-cloud-server").build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
MetaMenu nodeManager = MetaMenu.createRootMenu("$NodeManager", "微节点管理", "fa fa-cloud", 70);
MetaMenu nodeMenu = MetaMenu.createEruptClassMenu(CloudNode.class, nodeManager, 20);
return Arrays.asList(nodeManager,
MetaMenu.createEruptClassMenu(CloudNodeGroup.class, nodeManager, 10, MenuTypeEnum.TREE), nodeMenu,
MetaMenu.createSimpleMenu(
CloudServerConst.CLOUD_ACCESS_TOKEN_PERMISSION, "查看令牌",
CloudServerConst.CLOUD_ACCESS_TOKEN_PERMISSION, nodeMenu, 20, MenuTypeEnum.BUTTON.getCode()
),
MetaMenu.createSimpleMenu(
CloudServerConst.CLOUD_NODE_MANAGER_PERMISSION, "节点管理",
CloudServerConst.CLOUD_NODE_MANAGER_PERMISSION, nodeMenu, 30, MenuTypeEnum.BUTTON.getCode()
)
);
| 111
| 273
| 384
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/controller/EruptMicroserviceController.java
|
EruptMicroserviceController
|
registerNode
|
class EruptMicroserviceController {
private final EruptNodeMicroservice eruptNodeMicroservice;
@PostMapping(CloudRestApiConst.REGISTER_NODE)
public void registerNode(@RequestBody MetaNode metaNode, HttpServletRequest request, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
//移除实例
@PostMapping(CloudRestApiConst.REMOVE_INSTANCE_NODE)
public void removeInstanceNode(@RequestParam String nodeName, @RequestParam String accessToken, HttpServletRequest request) {
Optional.ofNullable(CloudServerUtil.findEruptCloudServerAnnotation()).ifPresent(it -> it.removeNode(nodeName, request));
eruptNodeMicroservice.safeRemoveInstance(nodeName, accessToken);
}
}
|
CloudNode cloudNode = eruptNodeMicroservice.findNodeByAppName(metaNode.getNodeName(), metaNode.getAccessToken());
if (!cloudNode.getStatus()) {
response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
throw new RuntimeException(metaNode.getNodeName() + " prohibiting the registration");
}
Optional.ofNullable(CloudServerUtil.findEruptCloudServerAnnotation()).ifPresent(it -> it.registerNode(metaNode, request));
for (String location : metaNode.getNodeAddress()) {
if (!CloudServerUtil.nodeHealth(metaNode.getNodeName(), location)) {
throw new RuntimeException("Unable to establish a connection with " + location);
}
}
eruptNodeMicroservice.registerNode(cloudNode, metaNode);
| 197
| 204
| 401
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/controller/EruptServerApi.java
|
EruptServerApi
|
getNodeGroupConfig
|
class EruptServerApi {
@Resource
private EruptDao eruptDao;
@Resource
private EruptSessionService eruptSessionService;
@Resource
private EruptContextService eruptContextService;
@Resource
private EruptUserService eruptUserService;
@Resource
private EruptNodeMicroservice eruptNodeMicroservice;
@GetMapping(CloudRestApiConst.ERUPT_POWER)
public PowerObject eruptPower(@RequestParam String eruptName, @RequestParam String nodeName) {
PowerObject powerObject = new PowerObject();
List<String> values = eruptSessionService.getMapKeys(SessionKey.MENU_VALUE_MAP + eruptContextService.getCurrentToken());
Map<String, Boolean> permissionMap = values.stream().collect(Collectors.toMap(it -> it, it -> true));
String name = nodeName + EruptConst.DOT + eruptName;
powerObject.setQuery(permissionMap.containsKey(name.toLowerCase()));
powerObject.setAdd(powerOff(EruptFunPermissions.ADD, permissionMap, name));
powerObject.setDelete(powerOff(EruptFunPermissions.DELETE, permissionMap, name));
powerObject.setAdd(powerOff(EruptFunPermissions.ADD, permissionMap, name));
powerObject.setEdit(powerOff(EruptFunPermissions.EDIT, permissionMap, name));
powerObject.setExport(powerOff(EruptFunPermissions.EXPORT, permissionMap, name));
powerObject.setImportable(powerOff(EruptFunPermissions.IMPORTABLE, permissionMap, name));
powerObject.setViewDetails(powerOff(EruptFunPermissions.VIEW_DETAIL, permissionMap, name));
return powerObject;
}
@GetMapping(CloudRestApiConst.NODE_CONFIG + "/{nodeName}")
public String getNodeConfig(@PathVariable String nodeName, @RequestHeader(CloudCommonConst.HEADER_ACCESS_TOKEN) String accessToken) {
return (String) eruptDao.getEntityManager()
.createQuery("select config from CloudNode where nodeName = :nodeName and accessToken = :accessToken")
.setParameter("nodeName", nodeName)
.setParameter("accessToken", accessToken).getSingleResult();
}
@GetMapping(CloudRestApiConst.NODE_GROUP_CONFIG + "/{nodeName}")
public String getNodeGroupConfig(@PathVariable String nodeName, @RequestHeader(CloudCommonConst.HEADER_ACCESS_TOKEN) String accessToken) {<FILL_FUNCTION_BODY>}
//用户信息
@GetMapping(CloudRestApiConst.ERUPT_USER_INFO + "/{nodeName}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public MetaUserinfo userinfo(@PathVariable String nodeName, @RequestHeader(CloudCommonConst.HEADER_ACCESS_TOKEN) String accessToken) {
eruptNodeMicroservice.findNodeByAppName(nodeName, accessToken);
return eruptUserService.getSimpleUserInfo();
}
private boolean powerOff(EruptFunPermissions eruptFunPermissions, Map<String, Boolean> permissionMap, String name) {
return permissionMap.containsKey(UPMSUtil.getEruptFunPermissionsCode(name, eruptFunPermissions).toLowerCase());
}
}
|
return (String) eruptDao.getEntityManager()
.createQuery("select cloudNodeGroup.config from CloudNode where nodeName = :nodeName and accessToken = :accessToken")
.setParameter("nodeName", nodeName)
.setParameter("accessToken", accessToken).getSingleResult();
| 856
| 76
| 932
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/distribute/ChannelSwapModel.java
|
ChannelSwapModel
|
create
|
class ChannelSwapModel {
private String instanceId;
private Command command;
private Object data;
private ChannelSwapModel() {
}
public static ChannelSwapModel create(String instanceId, Command command, Object data) {<FILL_FUNCTION_BODY>}
public enum Command {
PUT, REMOVE
}
}
|
ChannelSwapModel channelSwapModel = new ChannelSwapModel();
channelSwapModel.instanceId = instanceId;
channelSwapModel.command = command;
channelSwapModel.data = data;
return channelSwapModel;
| 97
| 63
| 160
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/model/CloudNode.java
|
CloudNode
|
afterFetch
|
class CloudNode extends MetaModelUpdateVo implements DataProxy<CloudNode>, TagsFetchHandler, Tpl.TplHandler {
public static final String NODE_NAME = LambdaSee.field(CloudNode::getNodeName);
public static final String ACCESS_TOKEN = LambdaSee.field(CloudNode::getAccessToken);
@Column(unique = true)
@EruptField(
views = @View(title = "节点名", sortable = true),
edit = @Edit(title = "节点名", desc = "NodeName", notNull = true, search = @Search(vague = true))
)
private String nodeName;
@EruptField(
views = @View(title = "友好名称", sortable = true),
edit = @Edit(title = "友好名称", notNull = true, search = @Search(vague = true))
)
private String name;
@ManyToOne
@EruptField(
views = @View(title = "所属分组", column = "name"),
edit = @Edit(title = "所属分组", type = EditType.REFERENCE_TREE, search = @Search)
)
private CloudNodeGroup cloudNodeGroup;
@EruptField(
views = @View(title = "状态", sortable = true),
edit = @Edit(title = "状态", search = @Search, notNull = true, boolType = @BoolType(
trueText = "启用", falseText = "禁用"
))
)
private Boolean status = true;
@Transient
@EruptField(
views = @View(title = "Erupt 类数量", className = "text-center", width = "120px")
)
private Integer eruptNum;
@Transient
@EruptField(
views = @View(title = "模块数", className = "text-center", width = "70px")
)
private Integer eruptModuleNum;
@Transient
@EruptField(
views = @View(title = "实例数", className = "text-center", width = "70px"
, tpl = @Tpl(path = "/tpl/node-instance.ftl", width = "400px", tplHandler = CloudNode.class)
)
)
private Integer instanceNum;
@Transient
@EruptField(
views = @View(title = "版本", className = "text-center", width = "120px")
)
private String version;
@EruptField(
views = @View(title = "负责人", sortable = true),
edit = @Edit(title = "负责人", type = EditType.TAGS,
tagsType = @TagsType(fetchHandler = CloudNode.class), notNull = true)
)
private String duty;
@Lob
@Type(type = "org.hibernate.type.TextType")
@EruptField(
views = @View(title = "节点配置"),
edit = @Edit(title = "节点配置", desc = "配置后可在子节点中读取", type = EditType.CODE_EDITOR, codeEditType = @CodeEditorType(language = "json"))
)
private String config;
@EruptField(
views = @View(title = "Access Token", width = "120px")
)
private String accessToken;
@Column(length = AnnotationConst.REMARK_LENGTH)
@EruptField(
views = @View(title = "描述", type = ViewType.HTML),
edit = @Edit(title = "描述", type = EditType.TEXTAREA)
)
private String remark;
@Transient
@Resource
private NodeManager nodeManager;
@Transient
@Resource
private EruptDao eruptDao;
@Override
public void afterUpdate(CloudNode cloudNode) {
DataProxy.super.afterUpdate(cloudNode);
}
@Override
public void beforeAdd(CloudNode cloudNode) {
if (null == cloudNode.getAccessToken()) cloudNode.setAccessToken(Erupts.generateCode(16).toUpperCase());
}
@Override
public void beforeUpdate(CloudNode cloudNode) {
this.beforeAdd(cloudNode);
}
@Override
public void afterFetch(Collection<Map<String, Object>> list) {<FILL_FUNCTION_BODY>}
@Override
public void afterDelete(CloudNode cloudNode) {
nodeManager.removeNode(cloudNode.getNodeName());
}
@Override
public List<String> fetchTags(String[] params) {
return eruptDao.getJdbcTemplate().queryForList("select name from e_upms_user", String.class);
}
@Override
public void bindTplData(Map<String, Object> binding, String[] params) {
CloudNode cloudNode = (CloudNode) binding.get(EngineConst.INJECT_ROW);
MetaNode metaNode = nodeManager.getNode(cloudNode.getNodeName());
if (null == metaNode) {
binding.put("instances", "[]");
} else {
binding.put("instances", GsonFactory.getGson().toJson(metaNode.getLocations()));
}
}
}
|
for (Map<String, Object> map : list) {
Optional.ofNullable(map.get(ACCESS_TOKEN)).ifPresent(it -> {
String token = it.toString();
map.put(ACCESS_TOKEN, token.substring(0, 3) + "******" + token.substring(token.length() - 3));
});
map.put(LambdaSee.field(CloudNode::getEruptNum), '-');
map.put(LambdaSee.field(CloudNode::getInstanceNum), '-');
map.put(LambdaSee.field(CloudNode::getVersion), '-');
map.put(LambdaSee.field(CloudNode::getEruptModuleNum), '-');
try {
MetaNode metaNode = nodeManager.getNode(map.get(NODE_NAME).toString());
Optional.ofNullable(nodeManager.getNode(map.get(NODE_NAME).toString())).ifPresent(metaNode1 -> {
Function<Collection<String>, Object> function = (it) -> null == it ? 0 : String.format("<a href='javascript:alert(`%s`);'>%d</a>", String.join("\\u000a", it), it.size());
map.put(LambdaSee.field(CloudNode::getEruptNum), function.apply(metaNode.getErupts()));
map.put(LambdaSee.field(CloudNode::getInstanceNum), metaNode.getLocations().size());
map.put(LambdaSee.field(CloudNode::getEruptModuleNum), function.apply(metaNode.getEruptModules()));
map.put(LambdaSee.field(CloudNode::getVersion), metaNode.getVersion());
});
} catch (Exception e) {
map.put(LambdaSee.field(CloudNode::getVersion), String.format("<span style='color:#f00'>%s</span>", e.getMessage()));
log.warn("node warn → " + map.get(NODE_NAME), e);
}
}
| 1,369
| 505
| 1,874
|
<methods>public non-sealed void <init>() <variables>private java.lang.String updateBy,private java.time.LocalDateTime updateTime
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/node/NodeManager.java
|
NodeManager
|
findAllNodes
|
class NodeManager {
public static final String NODE_SPACE = "node:";
@Resource
private EruptDao eruptDao;
private RedisTemplate<String, MetaNode> redisTemplate;
@Autowired
public void setRedisTemplate(RedisTemplate<?, ?> redisTemplate) {
RedisSerializer<String> stringSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(stringSerializer);
this.redisTemplate = (RedisTemplate<String, MetaNode>) redisTemplate;
}
@Resource
private EruptCloudServerProp eruptCloudServerProp;
private String geneKey(String nodeName) {
return eruptCloudServerProp.getCloudNameSpace() + NodeManager.NODE_SPACE + nodeName;
}
public MetaNode getNode(String nodeName) {
return redisTemplate.opsForValue().get(geneKey(nodeName));
}
public void putNode(MetaNode metaNode) {
if (metaNode.getLocations().isEmpty()) {
this.removeNode(metaNode.getNodeName());
} else {
redisTemplate.opsForValue().set(geneKey(metaNode.getNodeName()), metaNode,
eruptCloudServerProp.getNodeExpireTime(), TimeUnit.MILLISECONDS);
}
}
public void removeNode(String nodeName) {
redisTemplate.delete(geneKey(nodeName));
}
//移除指定实例
public void removeNodeInstance(String nodeName, String instanceAddress) {
MetaNode metaNode = getNode(nodeName);
metaNode.getLocations().removeIf(it -> it.equals(instanceAddress));
this.putNode(metaNode);
}
public List<MetaNode> findAllNodes() {<FILL_FUNCTION_BODY>}
}
|
List<String> keys = eruptDao.queryEntityList(CloudNode.class).stream().map(it ->
eruptCloudServerProp.getCloudNameSpace() + NODE_SPACE + it.getNodeName()
).collect(Collectors.toList());
if (!keys.isEmpty()) {
List<MetaNode> metaNodes = Optional.ofNullable(redisTemplate.opsForValue().multiGet(keys)).orElse(new ArrayList<>());
metaNodes.removeIf(Objects::isNull);
return metaNodes;
} else {
return new ArrayList<>();
}
| 480
| 148
| 628
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/node/NodeWorker.java
|
NodeWorker
|
run
|
class NodeWorker implements Runnable {
private final NodeManager nodeManager;
private final EruptCloudServerProp eruptCloudServerProp;
@PostConstruct
public void postConstruct() {
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(this, 0,
eruptCloudServerProp.getNodeSurviveCheckTime(), TimeUnit.MILLISECONDS);
}
@SneakyThrows
@Override
public void run() {<FILL_FUNCTION_BODY>}
}
|
for (MetaNode node : nodeManager.findAllNodes()) {
if (node.getLocations().removeIf(location ->
!CloudServerUtil.retryableNodeHealth(node.getNodeName(),
location, 2, 200))) {
nodeManager.putNode(node);
}
}
| 137
| 83
| 220
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/service/EruptNodeMicroservice.java
|
EruptNodeMicroservice
|
findNodeByAppName
|
class EruptNodeMicroservice {
@Resource
private EruptDao eruptDao;
@Resource
private NodeManager nodeManager;
@Resource
private NodeWorker nodeWorker;
@Resource
private EruptCloudServerProp eruptCloudServerProp;
public CloudNode findNodeByAppName(String nodeName, String accessToken) {<FILL_FUNCTION_BODY>}
public void registerNode(CloudNode cloudNode, MetaNode metaNode) {
Optional.ofNullable(nodeManager.getNode(metaNode.getNodeName())).ifPresent(it -> metaNode.getLocations().addAll(it.getLocations()));
metaNode.getLocations().addAll(Arrays.asList(metaNode.getNodeAddress()));
metaNode.setRegisterTime(new Date());
nodeManager.putNode(metaNode);
}
public void safeRemoveInstance(String nodeName, String accessToken) {
this.findNodeByAppName(nodeName, accessToken);
nodeWorker.run(); // 轮询nodeName下所有ip节点可用情况
}
}
|
CloudNode cloudNode = eruptDao.queryEntity(CloudNode.class, CloudNode.NODE_NAME + " = :" + CloudNode.NODE_NAME, new HashMap<String, Object>() {{
this.put(CloudNode.NODE_NAME, nodeName);
}});
if (null == cloudNode) {
throw new RuntimeException("NodeName: '" + nodeName + "' not found");
}
if (eruptCloudServerProp.isValidateAccessToken()) {
if (!cloudNode.getAccessToken().equals(accessToken)) {
throw new RuntimeException(cloudNode.getNodeName() + " Access token invalid");
}
}
return cloudNode;
| 282
| 170
| 452
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-cloud/erupt-cloud-server/src/main/java/xyz/erupt/cloud/server/util/CloudServerUtil.java
|
CloudServerUtil
|
nodeHealth
|
class CloudServerUtil {
public static EruptCloudServer.Proxy findEruptCloudServerAnnotation() {
EruptCloudServer eruptCloudServer = EruptApplication.getPrimarySource().getAnnotation(EruptCloudServer.class);
return null == eruptCloudServer ? null : EruptSpringUtil.getBean(eruptCloudServer.value());
}
//Node节点健康检查
public static boolean nodeHealth(String nodeName, String location) {<FILL_FUNCTION_BODY>}
//可重试的node节点检查
@SneakyThrows
public static boolean retryableNodeHealth(String nodeName, String location, int reqNum, int retryableGap) {
if (reqNum <= 0) {
log.error("remove node: {} -> {}", nodeName, location);
return false;
}
if (nodeHealth(nodeName, location)) {
return true;
} else {
Thread.sleep(retryableGap);
return retryableNodeHealth(nodeName, location, reqNum - 1, retryableGap);
}
}
}
|
try {
HttpResponse httpResponse = HttpUtil.createGet(location + CloudRestApiConst.NODE_HEALTH).timeout(1000).execute();
String body = httpResponse.body();
if (StringUtils.isNotBlank(body) && !nodeName.equals(body)) {
log.warn("nodeName mismatch {} != {}", nodeName, body);
return false;
}
return httpResponse.isOk();
} catch (Exception e) {
log.error(location, e);
return false;
}
| 279
| 140
| 419
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/cache/EruptCacheLRU.java
|
EruptCacheLRU
|
removeEldestEntry
|
class EruptCacheLRU<V> extends LinkedHashMap<String, EruptCacheLRU.ExpireNode<V>> implements EruptCache<V> {
private final int capacity;
private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public EruptCacheLRU(int capacity) {
super((int) Math.ceil(capacity / 0.75) + 1, 0.75f, true);
// 容量
this.capacity = capacity;
}
/**
* @param ttl 单位：毫秒
*/
@Override
public V put(String key, V v, long ttl) {
long expireTime = ttl > 0 ? (System.currentTimeMillis() + ttl) : Long.MAX_VALUE;
lock.writeLock().lock();
try {
this.put(key, new ExpireNode<>(expireTime, v));
return v;
} finally {
lock.writeLock().unlock();
}
}
@Override
public V get(String key) {
lock.readLock().lock();
ExpireNode<V> expireNode;
try {
expireNode = super.get(key);
} finally {
lock.readLock().unlock();
}
if (expireNode == null) return null;
if (expireNode.expire < System.currentTimeMillis()) {
try {
lock.writeLock().lock();
super.remove(key);
} finally {
lock.writeLock().unlock();
}
return null;
}
return expireNode.value;
}
@Override
public void delete(String key) {
try {
lock.writeLock().lock();
this.remove(key);
} finally {
lock.writeLock().unlock();
}
}
@Override
protected boolean removeEldestEntry(Map.Entry<String, ExpireNode<V>> eldest) {<FILL_FUNCTION_BODY>}
/**
* 清理已过期的数据
*/
protected void clean() {
try {
lock.writeLock().lock();
Iterator<Map.Entry<String, ExpireNode<V>>> iterator = super.entrySet().iterator();
long now = System.currentTimeMillis();
while (iterator.hasNext()) {
Map.Entry<String, ExpireNode<V>> next = iterator.next();
// 判断是否过期
if (next.getValue().expire < now) iterator.remove();
}
} finally {
lock.writeLock().unlock();
}
}
/**
* 过期时间节点
*/
public static class ExpireNode<V> {
private final long expire;
private final V value;
ExpireNode(long expire, V value) {
this.expire = expire;
this.value = value;
}
}
}
|
if (this.size() > capacity) this.clean();
return this.size() > this.capacity;
| 759
| 31
| 790
|
<methods>public void <init>() ,public void <init>(int) ,public void <init>(Map<? extends java.lang.String,? extends ExpireNode<V>>) ,public void <init>(int, float) ,public void <init>(int, float, boolean) ,public void clear() ,public boolean containsValue(java.lang.Object) ,public Set<Entry<java.lang.String,ExpireNode<V>>> entrySet() ,public void forEach(BiConsumer<? super java.lang.String,? super ExpireNode<V>>) ,public ExpireNode<V> get(java.lang.Object) ,public ExpireNode<V> getOrDefault(java.lang.Object, ExpireNode<V>) ,public Set<java.lang.String> keySet() ,public void replaceAll(BiFunction<? super java.lang.String,? super ExpireNode<V>,? extends ExpireNode<V>>) ,public Collection<ExpireNode<V>> values() <variables>final boolean accessOrder,transient Entry<java.lang.String,ExpireNode<V>> head,private static final long serialVersionUID,transient Entry<java.lang.String,ExpireNode<V>> tail
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/config/EruptGsonExclusionStrategies.java
|
EruptGsonExclusionStrategies
|
shouldSkipField
|
class EruptGsonExclusionStrategies implements ExclusionStrategy {
@Override
@SneakyThrows
public boolean shouldSkipField(FieldAttributes f) {<FILL_FUNCTION_BODY>}
@Override
public boolean shouldSkipClass(Class<?> incomingClass) {
return false;
}
}
|
MetaErupt metaErupt = MetaContext.getErupt();
if (null == metaErupt || null == metaErupt.getName()) return false;
if (null == f.getAnnotation(EruptSmartSkipSerialize.class)) return false;
Class<?> currEruptClass = EruptCoreService.getErupt(metaErupt.getName()).getClazz();
if (f.getDeclaringClass().isAssignableFrom(currEruptClass)) {
Field ff = ReflectUtil.findClassField(currEruptClass, f.getName());
if (null == ff) return false;
return !f.getDeclaringClass().getName().equals(ff.getDeclaringClass().getName());
} else {
return true;
}
| 86
| 192
| 278
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/config/MvcConfig.java
|
MvcConfig
|
addResourceHandlers
|
class MvcConfig implements WebMvcConfigurer {
private final EruptProp eruptProp;
private final Set<String> gsonMessageConverterPackage = Stream.of(EruptConst.BASE_PACKAGE, Gson.class.getPackage().getName()).collect(Collectors.toSet());
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
Optional.ofNullable(eruptProp.getGsonHttpMessageConvertersPackages()).ifPresent(it -> gsonMessageConverterPackage.addAll(Arrays.asList(it)));
converters.add(0, new GsonHttpMessageConverter(GsonFactory.getGson()) {
@Override
protected boolean supports(Class<?> clazz) {
for (String pack : gsonMessageConverterPackage) {
if (clazz.getName().startsWith(pack)) {
return super.supports(clazz);
}
}
return false;
}
});
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {<FILL_FUNCTION_BODY>}
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
UrlPathHelper helper = new UrlPathHelper();
helper.setUrlDecode(false);
helper.setDefaultEncoding(StandardCharsets.UTF_8.name());
configurer.setUrlPathHelper(helper);
}
}
|
String uploadPath = eruptProp.getUploadPath().endsWith("/") ? eruptProp.getUploadPath() : eruptProp.getUploadPath() + "/";
ResourceHandlerRegistration resourceHandlerRegistration = registry.addResourceHandler(EruptRestPath.ERUPT_ATTACHMENT + "/**");
if (uploadPath.startsWith("classpath:")) {
resourceHandlerRegistration.addResourceLocations(uploadPath);
} else {
resourceHandlerRegistration.addResourceLocations("file:" + uploadPath);
}
| 363
| 133
| 496
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/controller/EruptBuildController.java
|
EruptBuildController
|
getEruptBuild
|
class EruptBuildController {
@GetMapping("/{erupt}")
@EruptRouter(authIndex = 1, verifyType = EruptRouter.VerifyType.ERUPT)
@SneakyThrows
public EruptBuildModel getEruptBuild(@PathVariable("erupt") String eruptName) {<FILL_FUNCTION_BODY>}
@GetMapping("/{erupt}/{field}")
@EruptRouter(authIndex = 1, verifyType = EruptRouter.VerifyType.ERUPT)
public EruptBuildModel getEruptBuildByField(@PathVariable("erupt") String eruptName, @PathVariable("field") String field) {
return this.getEruptBuild(EruptCoreService.getEruptView(eruptName).getEruptFieldMap().get(field).getFieldReturnName());
}
}
|
EruptModel eruptView = EruptCoreService.getEruptView(eruptName);
{
//default search conditions
Map<String, Object> conditionsMap = new HashMap<>();
DataProxyInvoke.invoke(eruptView, it -> it.searchCondition(conditionsMap));
eruptView.setSearchCondition(conditionsMap);
}
EruptBuildModel eruptBuildModel = new EruptBuildModel();
eruptBuildModel.setPower(PowerInvoke.getPowerObject(eruptView));
eruptBuildModel.setEruptModel(eruptView);
eruptView.getEruptFieldModels().forEach(fieldModel -> {
switch (fieldModel.getEruptField().edit().type()) {
case TAB_TREE:
eruptBuildModel.setTabErupts(Optional.ofNullable(eruptBuildModel.getTabErupts()).orElse(new LinkedHashMap<>()));
EruptBuildModel m1 = new EruptBuildModel();
m1.setEruptModel(EruptCoreService.getEruptView(fieldModel.getFieldReturnName()));
eruptBuildModel.getTabErupts().put(fieldModel.getFieldName(), m1);
break;
case TAB_TABLE_ADD:
case TAB_TABLE_REFER:
eruptBuildModel.setTabErupts(Optional.ofNullable(eruptBuildModel.getTabErupts()).orElse(new LinkedHashMap<>()));
eruptBuildModel.getTabErupts().put(fieldModel.getFieldName(), getEruptBuild(fieldModel.getFieldReturnName()));
break;
case COMBINE:
eruptBuildModel.setCombineErupts(Optional.ofNullable(eruptBuildModel.getCombineErupts()).orElse(new LinkedHashMap<>()));
eruptBuildModel.getCombineErupts().put(fieldModel.getFieldName(), EruptCoreService.getEruptView(fieldModel.getFieldReturnName()));
break;
}
});
Arrays.stream(eruptBuildModel.getEruptModel().getErupt().rowOperation()).filter(operation ->
operation.eruptClass() != void.class && operation.type() == RowOperation.Type.ERUPT).forEach(operation -> {
eruptBuildModel.setOperationErupts(Optional.ofNullable(eruptBuildModel.getOperationErupts()).orElse(new LinkedHashMap<>()));
eruptBuildModel.getOperationErupts().put(operation.code(), EruptCoreService.getEruptView(operation.eruptClass().getSimpleName()));
});
return eruptBuildModel;
| 214
| 652
| 866
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/controller/EruptComponentController.java
|
EruptComponentController
|
codeEditHints
|
class EruptComponentController {
/**
* 自动完成组件联动接口
*
* @param field 自动完成组件字段
* @param val 输入框的值
* @param formData 完整表单对象
* @return 联想结果
*/
@PostMapping("/auto-complete/{erupt}/{field}")
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public List<Object> findAutoCompleteValue(@PathVariable("erupt") String eruptName,
@PathVariable("field") String field,
@RequestParam("val") String val,
@RequestBody(required = false) Map<String, Object> formData) {
EruptFieldModel fieldModel = EruptCoreService.getErupt(eruptName).getEruptFieldMap().get(field);
AutoCompleteType autoCompleteType = fieldModel.getEruptField().edit().autoCompleteType();
if (val.length() < autoCompleteType.triggerLength()) {
throw new EruptWebApiRuntimeException("char length must >= " + autoCompleteType.triggerLength());
}
try {
return EruptSpringUtil.getBean(autoCompleteType.handler()).completeHandler(formData, val, autoCompleteType.param());
} catch (Exception e) {
throw new EruptApiErrorTip(e.getMessage(), EruptApiModel.PromptWay.MESSAGE);
}
}
//Gets the CHOICE component drop-down list
@GetMapping("/choice-item/{erupt}/{field}")
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public List<VLModel> findChoiceItem(@PathVariable("erupt") String eruptName,
@PathVariable("field") String field) {
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
EruptFieldModel fieldModel = eruptModel.getEruptFieldMap().get(field);
return EruptUtil.getChoiceList(eruptModel, fieldModel.getEruptField().edit().choiceType());
}
//Gets the TAGS component data
@GetMapping("/tags-item/{erupt}/{field}")
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public List<String> findTagsItem(@PathVariable("erupt") String eruptName,
@PathVariable("field") String field) {
EruptFieldModel fieldModel = EruptCoreService.getErupt(eruptName).getEruptFieldMap().get(field);
return EruptUtil.getTagList(fieldModel.getEruptField().edit().tagsType());
}
//Gets the CodeEdit component hint data
@GetMapping("/code-edit-hints/{erupt}/{field}")
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public List<String> codeEditHints(@PathVariable("erupt") String eruptName,
@PathVariable("field") String field) {<FILL_FUNCTION_BODY>}
}
|
EruptFieldModel fieldModel = EruptCoreService.getErupt(eruptName).getEruptFieldMap().get(field);
CodeEditorType codeEditType = fieldModel.getEruptField().edit().codeEditType();
return EruptSpringUtil.getBean(codeEditType.hint()).hint(codeEditType.hintParams());
| 801
| 88
| 889
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/controller/EruptTabController.java
|
EruptTabController
|
updateTabEruptData
|
class EruptTabController {
private final Gson gson = GsonFactory.getGson();
//TAB组件新增行为
@PostMapping({"/tab-add/{erupt}/{tabName}"})
@EruptRouter(skipAuthIndex = 3, authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public EruptApiModel addTabEruptData(@PathVariable("erupt") String erupt, @PathVariable("tabName") String tabName, @RequestBody JsonObject data) {
EruptModel eruptModel = getTabErupt(erupt, tabName);
Object obj = gson.fromJson(data.toString(), eruptModel.getClazz());
EruptApiModel eruptApiModel = this.tabValidate(eruptModel, data, dp -> {
dp.beforeAdd(obj);
dp.afterAdd(obj);
});
eruptApiModel.setData(obj);
return eruptApiModel;
}
//TAB组件更新行为
@PostMapping({"/tab-update/{erupt}/{tabName}"})
@EruptRouter(skipAuthIndex = 3, authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public EruptApiModel updateTabEruptData(@PathVariable("erupt") String erupt, @PathVariable("tabName") String tabName, @RequestBody JsonObject data) {<FILL_FUNCTION_BODY>}
//TAB组件删除行为
@PostMapping({"/tab-delete/{erupt}/{tabName}"})
@EruptRouter(skipAuthIndex = 3, authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public EruptApiModel deleteTabEruptData(@PathVariable("erupt") String erupt, @PathVariable("tabName") String tabName, @RequestBody JsonObject data) {
EruptApiModel eruptApiModel = EruptApiModel.successApi();
EruptModel eruptModel = getTabErupt(erupt, tabName);
Object obj = gson.fromJson(data.toString(), eruptModel.getClazz());
DataProxyInvoke.invoke(eruptModel, dp -> {
dp.beforeDelete(obj);
dp.afterDelete(obj);
});
eruptApiModel.setPromptWay(EruptApiModel.PromptWay.MESSAGE);
return eruptApiModel;
}
private EruptApiModel tabValidate(EruptModel eruptModel, JsonObject data, Consumer<DataProxy<Object>> consumer) {
EruptApiModel eruptApiModel = EruptUtil.validateEruptValue(eruptModel, data);
if (eruptApiModel.getStatus() == EruptApiModel.Status.SUCCESS) {
DataProxyInvoke.invoke(eruptModel, consumer);
}
eruptApiModel.setErrorIntercept(false);
eruptApiModel.setPromptWay(EruptApiModel.PromptWay.MESSAGE);
return eruptApiModel;
}
private EruptModel getTabErupt(String erupt, String tabName) {
EruptFieldModel tabField = EruptCoreService.getErupt(erupt).getEruptFieldMap().get(tabName);
if (null == tabField) {
throw new EruptWebApiRuntimeException(tabName + "not found");
}
return EruptCoreService.getErupt(tabField.getFieldReturnName());
}
}
|
EruptModel eruptModel = getTabErupt(erupt, tabName);
Object obj = gson.fromJson(data.toString(), eruptModel.getClazz());
EruptApiModel eruptApiModel = this.tabValidate(eruptModel, data, dp -> {
dp.beforeUpdate(obj);
dp.afterUpdate(obj);
});
eruptApiModel.setData(obj);
return eruptApiModel;
| 877
| 117
| 994
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/controller/advice/EruptExceptionAdvice.java
|
EruptExceptionAdvice
|
eruptException
|
class EruptExceptionAdvice {
private static final String ERE = "erupt exception";
@ExceptionHandler(EruptApiErrorTip.class)
@ResponseStatus(value = HttpStatus.OK)
@ResponseBody
public EruptApiModel eruptApiErrorTip(EruptApiErrorTip e) {
log.error(ERE, e);
e.eruptApiModel.setErrorIntercept(false);
return e.eruptApiModel;
}
@ResponseBody
@ExceptionHandler(Exception.class)
public EruptExceptionVo eruptException(Exception e, HttpServletRequest request, HttpServletResponse response) {<FILL_FUNCTION_BODY>}
}
|
response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
log.error(ERE, e);
return new EruptExceptionVo(request.getServletPath(), response.getStatus(), ERE, e instanceof RuntimeException ? e.getMessage() : null);
| 174
| 70
| 244
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/exception/EruptAnnotationException.java
|
EruptAnnotationException
|
validateEruptInfo
|
class EruptAnnotationException extends RuntimeException {
public EruptAnnotationException(String message) {
super(message);
}
public static void validateEruptInfo(EruptModel eruptModel) {<FILL_FUNCTION_BODY>}
}
|
if (null == eruptModel.getEruptFieldMap().get(eruptModel.getErupt().primaryKeyCol())) {
throw ExceptionAnsi.styleEruptException(eruptModel, "找不到主键,请确认主键列名是否为" + eruptModel.getErupt().primaryKeyCol() +
"，如果你不想将主键名定义为'" + eruptModel.getErupt().primaryKeyCol() + "'则可以修改@erupt->primaryKeyCol值解决此异常");
}
| 66
| 128
| 194
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/exception/EruptFieldAnnotationException.java
|
EruptFieldAnnotationException
|
validateEruptFieldInfo
|
class EruptFieldAnnotationException extends RuntimeException {
public EruptFieldAnnotationException(String message) {
super(message);
}
public static void validateEruptFieldInfo(EruptFieldModel eruptFieldModel) {<FILL_FUNCTION_BODY>}
}
|
Edit edit = eruptFieldModel.getEruptField().edit();
switch (edit.type()) {
case REFERENCE_TREE:
case REFERENCE_TABLE:
for (View view : eruptFieldModel.getEruptField().views()) {
if ("".equals(view.column())) {
throw ExceptionAnsi.styleEruptFieldException(eruptFieldModel, "@View注解修饰复杂对象，必须配置column值 → " + view.title());
}
}
break;
}
| 70
| 133
| 203
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/exception/ExceptionAnsi.java
|
ExceptionAnsi
|
styleEruptFieldException
|
class ExceptionAnsi {
public static EruptFieldAnnotationException styleEruptFieldException(EruptFieldModel eruptFieldModel, String message) {<FILL_FUNCTION_BODY>}
public static EruptAnnotationException styleEruptException(EruptModel eruptModel, String message) {
return new EruptAnnotationException(
ansi().fg(Ansi.Color.RED).a(message)
+ ansi().fg(Ansi.Color.BLUE).
a("(" + eruptModel.getClazz().getName() + ")").reset().toString()
);
}
}
|
return new EruptFieldAnnotationException(
ansi().fg(Ansi.Color.RED).a(message).fg(Ansi.Color.BLUE)
.a("(" + eruptFieldModel.getField().getDeclaringClass().getName() + EruptConst.DOT
+ eruptFieldModel.getField().getName() + ")").reset().toString()
);
| 147
| 93
| 240
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/i18n/I18nRunner.java
|
I18nRunner
|
run
|
class I18nRunner extends LinkedCaseInsensitiveMap<Map<String, String>> implements ApplicationRunner {
//语言文件对应文字映射
private static final I18nRunner langMappings = new I18nRunner();
private static final String I18N_EXT = ".csv";
public static String getI18nValue(String lang, String key) {
if (null == langMappings.get(lang)) {
return key;
}
return Optional.ofNullable(langMappings.get(lang).get(key)).orElse(key);
}
@Override
@SneakyThrows
public void run(ApplicationArguments args) {<FILL_FUNCTION_BODY>}
@SneakyThrows
private void scanFile(File file) {
BasicFileAttributes fileAttributes = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
if (fileAttributes.isRegularFile()) {
final String fileName = file.getAbsolutePath();
if (fileName.endsWith(I18N_EXT)) {
@Cleanup FileInputStream fileInputStream = new FileInputStream(file);
@Cleanup InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
this.writeLang(inputStreamReader);
}
} else if (fileAttributes.isDirectory()) {
Optional.ofNullable(file.listFiles()).ifPresent(files -> Arrays.stream(files).forEach(this::scanFile));
}
}
@SneakyThrows
private void scanJar(JarFile jar) {
Enumeration<JarEntry> jarEntryEnumeration = jar.entries();
while (jarEntryEnumeration.hasMoreElements()) {
final JarEntry entry = jarEntryEnumeration.nextElement();
if (entry.getName().endsWith(I18N_EXT)) {
try (InputStreamReader inputStreamReader = new InputStreamReader(
jar.getInputStream(entry), StandardCharsets.UTF_8)) {
this.writeLang(inputStreamReader);
}
}
}
}
@SneakyThrows
private void writeLang(InputStreamReader inputStreamReader) {
@Cleanup BufferedReader reader = new BufferedReader(inputStreamReader);
String line;
List<String> header = new ArrayList<>();
boolean first = true;
while ((line = reader.readLine()) != null) {
String[] row = line.split(",");
for (int i = 0; i < row.length; i++) {
if (first) {
header.add(row[i]);
if (!langMappings.containsKey(row[i])) {
langMappings.put(row[i], new HashMap<>());
}
} else {
if (i < header.size()) {
if (null != row[i]) {
if (row[i].startsWith("\"") && row[i].endsWith("\"")) {
row[i] = row[i].substring(1, row[i].length() - 1);
}
langMappings.get(header.get(i)).put(row[0], row[i]);
}
}
}
}
first = false;
}
}
}
|
Enumeration<URL> urls = I18nRunner.class.getClassLoader().getResources("i18n/");
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
switch (url.getProtocol()) {
case "file":
scanFile(new File(URLDecoder.decode(url.getFile(), Charset.defaultCharset().name())));
break;
case "jar":
JarURLConnection urlConnection = (JarURLConnection) url.openConnection();
scanJar(urlConnection.getJarFile());
break;
}
}
| 831
| 156
| 987
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/i18n/I18nTranslate.java
|
I18nTranslate
|
getLang
|
class I18nTranslate {
@Resource
private HttpServletRequest request;
@Resource
private EruptProp eruptProp;
public static String $translate(String key) {
return EruptSpringUtil.getBean(I18nTranslate.class).translate(key);
}
public String translate(String key) {
String lang = getLang();
return I18nRunner.getI18nValue(lang == null ? eruptProp.getDefaultLocales() : lang, key);
}
public String getLang() {<FILL_FUNCTION_BODY>}
}
|
try {
return request.getHeader("lang");
} catch (Exception ignored) {
return null;
}
| 160
| 34
| 194
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/invoke/DataProcessorManager.java
|
DataProcessorManager
|
getEruptDataProcessor
|
class DataProcessorManager {
private static final Map<String, Class<? extends IEruptDataService>> eruptDataServiceMap = new HashMap<>();
public static void register(String name, Class<? extends IEruptDataService> eruptDataService) {
eruptDataServiceMap.put(name, eruptDataService);
}
public static IEruptDataService getEruptDataProcessor(Class<?> clazz) {<FILL_FUNCTION_BODY>}
}
|
EruptDataProcessor eruptDataProcessor = clazz.getAnnotation(EruptDataProcessor.class);
return EruptSpringUtil.getBean(eruptDataServiceMap.get(null == eruptDataProcessor ?
EruptConst.DEFAULT_DATA_PROCESSOR : eruptDataProcessor.value()));
| 119
| 75
| 194
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/invoke/DataProxyInvoke.java
|
DataProxyInvoke
|
invoke
|
class DataProxyInvoke {
public static void invoke(EruptModel eruptModel, Consumer<DataProxy<Object>> consumer) {<FILL_FUNCTION_BODY>}
private static void actionInvokePreDataProxy(Class<?> clazz, Consumer<DataProxy<Object>> consumer) {
//接口
Stream.of(clazz.getInterfaces()).forEach(it -> Optional.ofNullable(it.getAnnotation(PreDataProxy.class))
.ifPresent(dataProxy -> consumer.accept(getInstanceBean(dataProxy.value()))));
//类
Optional.ofNullable(clazz.getAnnotation(PreDataProxy.class))
.ifPresent(dataProxy -> consumer.accept(getInstanceBean(dataProxy.value())));
}
private static DataProxy<Object> getInstanceBean(Class<? extends DataProxy<?>> dataProxy) {
return (DataProxy) EruptSpringUtil.getBean(dataProxy);
}
}
|
//父类及接口 @PreDataProxy
ReflectUtil.findClassExtendStack(eruptModel.getClazz()).forEach(clazz -> DataProxyInvoke.actionInvokePreDataProxy(clazz, consumer));
//本类及接口 @PreDataProxy
DataProxyInvoke.actionInvokePreDataProxy(eruptModel.getClazz(), consumer);
//@Erupt → DataProxy
Stream.of(eruptModel.getErupt().dataProxy()).forEach(proxy -> consumer.accept(getInstanceBean(proxy)));
| 239
| 135
| 374
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/invoke/ExprInvoke.java
|
ExprInvoke
|
getExpr
|
class ExprInvoke {
public static String getExpr(Expr expr) {
String value = expr.value();
if (!expr.exprHandler().isInterface()) {
value = EruptSpringUtil.getBean(expr.exprHandler()).handler(value, expr.params());
}
return value;
}
public static Boolean getExpr(ExprBool expr) {
boolean value = expr.value();
if (!expr.exprHandler().isInterface()) {
value = EruptSpringUtil.getBean(expr.exprHandler()).handler(value, expr.params());
}
return value;
}
public static int getExpr(ExprInt expr) {
int value = expr.value();
if (!expr.exprHandler().isInterface()) {
value = EruptSpringUtil.getBean(expr.exprHandler()).handler(value, expr.params());
}
return value;
}
public static float getExpr(ExprFloat expr) {<FILL_FUNCTION_BODY>}
public static Class<?> getExpr(ExprClass expr) {
Class<?> value = expr.value();
if (!expr.exprHandler().isInterface()) {
value = EruptSpringUtil.getBean(expr.exprHandler()).handler(value, expr.params());
}
return value;
}
}
|
float value = expr.value();
if (!expr.exprHandler().isInterface()) {
value = EruptSpringUtil.getBean(expr.exprHandler()).handler(value, expr.params());
}
return value;
| 347
| 61
| 408
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/invoke/PowerInvoke.java
|
PowerInvoke
|
getPowerObject
|
class PowerInvoke {
private static final List<Class<? extends PowerHandler>> powerHandlerStack = new ArrayList<>();
public static void registerPowerHandler(Class<? extends PowerHandler> powerHandler) {
powerHandlerStack.add(powerHandler);
}
//动态获取erupt power值
public static PowerObject getPowerObject(EruptModel eruptModel) {<FILL_FUNCTION_BODY>}
}
|
Power power = eruptModel.getErupt().power();
if (eruptModel.getErupt().authVerify()) {
PowerObject powerBean = new PowerObject(power);
if (eruptModel.getErupt().authVerify()) {
powerHandlerStack.forEach(ph -> EruptSpringUtil.getBean(ph).handler(powerBean));
}
if (!power.powerHandler().isInterface()) EruptSpringUtil.getBean(power.powerHandler()).handler(powerBean);
return powerBean;
} else {
return new PowerObject(power);
}
| 106
| 147
| 253
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/module/MetaMenu.java
|
MetaMenu
|
createSimpleMenu
|
class MetaMenu {
private Long id; //无需传递此参数
private String code;
private String name;
private MenuStatus status;
private String type;
private String value;
private Integer sort;
private String icon;
private MetaMenu parentMenu;
public MetaMenu() {
}
public static MetaMenu createRootMenu(String code, String name, String icon, Integer sort) {
MetaMenu metaMenu = new MetaMenu();
metaMenu.code = code;
metaMenu.name = name;
metaMenu.status = MenuStatus.OPEN;
metaMenu.sort = sort;
metaMenu.icon = icon;
return metaMenu;
}
public static MetaMenu createSimpleMenu(String code, String name, String value, MetaMenu parent, Integer sort, String icon, String type, MenuStatus menuStatus) {<FILL_FUNCTION_BODY>}
public static MetaMenu createSimpleMenu(String code, String name, String value, MetaMenu parent, Integer sort, String type) {
return createSimpleMenu(code, name, value, parent, sort, null, type, MenuStatus.OPEN);
}
public static MetaMenu createEruptClassMenu(Class<?> eruptClass, MetaMenu parent, Integer sort, MenuTypeEnum menuTypeEnum, MenuStatus menuStatus) {
return createSimpleMenu(eruptClass.getSimpleName(), eruptClass.getAnnotation(Erupt.class).name(),
eruptClass.getSimpleName(), parent, sort, "", menuTypeEnum.getCode(), menuStatus);
}
public static MetaMenu createEruptClassMenu(Class<?> eruptClass, MetaMenu parent, Integer sort) {
return createEruptClassMenu(eruptClass, parent, sort, MenuTypeEnum.TABLE, MenuStatus.OPEN);
}
public static MetaMenu createEruptClassMenu(Class<?> eruptClass, MetaMenu parent, Integer sort, MenuStatus menuStatus) {
return createEruptClassMenu(eruptClass, parent, sort, MenuTypeEnum.TABLE, menuStatus);
}
public static MetaMenu createEruptClassMenu(Class<?> eruptClass, MetaMenu parent, Integer sort, MenuTypeEnum menuTypeEnum) {
return createEruptClassMenu(eruptClass, parent, sort, menuTypeEnum, MenuStatus.OPEN);
}
}
|
MetaMenu metaMenu = new MetaMenu();
metaMenu.code = code;
metaMenu.name = name;
metaMenu.status = menuStatus;
metaMenu.type = type;
metaMenu.value = value;
metaMenu.sort = sort;
metaMenu.parentMenu = parent;
metaMenu.icon = icon;
return metaMenu;
| 603
| 96
| 699
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/naming/EruptRecordNaming.java
|
EruptRecordNaming
|
naming
|
class EruptRecordNaming implements EruptRecordOperate.DynamicConfig {
@Override
public String naming(String desc, String menuName, String eruptName, Method method) {<FILL_FUNCTION_BODY>}
}
|
EruptRouter eruptRouter = method.getAnnotation(EruptRouter.class);
if (null != eruptRouter && eruptRouter.verifyType() == EruptRouter.VerifyType.ERUPT) {
String prefix = desc + " | ";
if (null != menuName) {
return prefix + menuName;
} else if (null != EruptCoreService.getErupt(eruptName)) {
return prefix + EruptCoreService.getErupt(eruptName).getErupt().name();
} else {
return prefix + eruptName;
}
} else {
throw new RuntimeException("incorrect use " + EruptRecordNaming.class.getSimpleName());
}
| 60
| 187
| 247
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/naming/EruptRowOperationNaming.java
|
EruptRowOperationNaming
|
findRowOperation
|
class EruptRowOperationNaming implements EruptRecordOperate.DynamicConfig {
@Resource
private HttpServletRequest request;
@Override
public String naming(String desc, String menuName, String eruptName, Method method) {
EruptModel erupt = EruptCoreService.getErupt(eruptName);
if (null == erupt) {
return menuName + " | @RowOperation";
}
return findRowOperation(erupt).title() + " | " + erupt.getErupt().name();
}
private RowOperation findRowOperation(EruptModel eruptModel) {<FILL_FUNCTION_BODY>}
}
|
String code = request.getServletPath().split(EruptDataController.OPERATOR_PATH_STR + "/")[1];
return Arrays.stream(eruptModel.getErupt().rowOperation())
.filter(operation -> operation.code().equals(code)).findFirst()
.orElseThrow(() -> new RuntimeException(eruptModel.getEruptName() + " RowOperation not found " + code));
| 166
| 105
| 271
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/AnnotationProcess.java
|
AnnotationProcess
|
annotationToJsonByReflect
|
class AnnotationProcess {
private static final String[] ANNOTATION_NUMBER_TYPE = {"short", "int", "long", "float", "double"};
private static final String[] ANNOTATION_STRING_TYPE = {"String", "byte", "char"};
private static final String EMPTY_ARRAY = "[]";
private static final String VALUE_VAR = "value";
private static final String ITEM_VAR = "item";
private static final ExpressionParser parser = new SpelExpressionParser();
@SneakyThrows
public static JsonObject annotationToJsonByReflect(Annotation annotation) {<FILL_FUNCTION_BODY>}
// erupt annotation 最原始序列化实现，收藏 ✨
@Deprecated
public static String annotationToJsonByReplace(String annotationStr) throws JSONException {
String convertStr = annotationStr
.replaceAll("@xyz\\.erupt\\.annotation\\.sub_field\\.sub_edit\\.sub_attachment\\.\\w+", "")
.replaceAll("@xyz\\.erupt\\.annotation\\.sub_field\\.sub_edit\\.\\w+", "")
.replaceAll("@xyz\\.erupt\\.annotation\\.sub_field\\.sub_view\\.\\w+", "")
.replaceAll("@xyz\\.erupt\\.annotation\\.sub_field\\.\\w+", "")
.replaceAll("@xyz\\.erupt\\.annotation\\.sub_erupt\\.\\w+", "")
.replaceAll("@xyz\\.erupt\\.annotation\\.\\w+", "")
//屏蔽类信息
.replaceAll("class [a-zA-Z0-9.]+", "")
.replace("=,", "='',")
.replace("=)", "='')")
.replace("=", ":")
.replace("(", "{")
.replace(")", "}");
return new JSONObject(convertStr).toString();
}
@SneakyThrows
public static EditTypeMapping getEditTypeMapping(EditType editType) {
return EditType.class.getDeclaredField(editType.name()).getAnnotation(EditTypeMapping.class);
}
@SneakyThrows
public static EditTypeSearch getEditTypeSearch(EditType editType) {
return EditType.class.getDeclaredField(editType.name()).getAnnotation(EditTypeSearch.class);
}
}
|
JsonObject jsonObject = new JsonObject();
for (Method method : annotation.annotationType().getDeclaredMethods()) {
Transient tran = method.getAnnotation(Transient.class);
if (null != tran && tran.value()) continue;
String methodName = method.getName();
EruptProperty eruptProperty = method.getAnnotation(EruptProperty.class);
if (null != eruptProperty && !AnnotationConst.EMPTY_STR.equals(eruptProperty.alias())) {
methodName = eruptProperty.alias();
}
String returnType = method.getReturnType().getSimpleName();
Object result = method.invoke(annotation);
Match match = method.getAnnotation(Match.class);
if (null != match) {
EvaluationContext evaluationContext = new StandardEvaluationContext();
evaluationContext.setVariable(VALUE_VAR, result);
evaluationContext.setVariable(ITEM_VAR, annotation);
Object r = parser.parseExpression(match.value()).getValue(evaluationContext);
if (null == r || !(Boolean) r) continue;
}
if (returnType.endsWith(EMPTY_ARRAY)) {
returnType = returnType.substring(0, returnType.length() - 2);
JsonArray jsonArray = new JsonArray();
ToMap toMap = method.getAnnotation(ToMap.class);
JsonObject jsonMap = new JsonObject();
//基本类型无法强转成Object类型数组，所以使用下面的方法进行处理
if (Arrays.asList(ANNOTATION_NUMBER_TYPE).contains(returnType)) {
TypeUtil.simpleNumberTypeArrayToObject(result, returnType, jsonArray::add);
} else {
for (Object res : (Object[]) result) {
if (String.class.getSimpleName().equals(returnType)) {
jsonArray.add(res.toString());
} else if (char.class.getSimpleName().equals(returnType)) {
jsonArray.add((Character) res);
} else if (byte.class.getSimpleName().equals(returnType)) {
jsonArray.add((Character) res);
} else if (boolean.class.getSimpleName().equals(returnType)) {
jsonArray.add((Boolean) res);
} else if (Class.class.getSimpleName().equals(returnType)) {
jsonArray.add(((Class<?>) res).getSimpleName());
} else if (res.getClass().isEnum()) {
jsonArray.add(res.toString());
} else {
Annotation ann = (Annotation) res;
if (null != toMap) {
JsonObject jo = annotationToJsonByReflect((Annotation) res);
String key = ann.annotationType().getMethod(toMap.key()).invoke(res).toString();
jo.remove(toMap.key());
jsonMap.add(key, jo);
} else {
jsonArray.add(annotationToJsonByReflect(ann));
}
}
}
}
if (null == toMap) {
jsonObject.add(methodName, jsonArray);
} else {
if (jsonMap.size() > 0) jsonObject.add(methodName, jsonMap);
}
} else {
if (Arrays.asList(ANNOTATION_STRING_TYPE).contains(returnType)) {
jsonObject.addProperty(methodName, result.toString());
} else if (Arrays.asList(ANNOTATION_NUMBER_TYPE).contains(returnType)) {
jsonObject.addProperty(methodName, (Number) result);
} else if (boolean.class.getSimpleName().equals(returnType)) {
jsonObject.addProperty(methodName, (Boolean) result);
} else if (method.getReturnType().isEnum()) {
jsonObject.addProperty(methodName, result.toString());
} else if (method.getReturnType().isAnnotation()) {
jsonObject.add(methodName, annotationToJsonByReflect((Annotation) result));
} else if (Class.class.getSimpleName().equals(returnType)) {
jsonObject.addProperty(methodName, ((Class<?>) result).getSimpleName());
}
}
}
return jsonObject;
| 624
| 1,052
| 1,676
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/AnnotationProxy.java
|
AnnotationProxy
|
newProxy
|
class AnnotationProxy<A, PA> {
// 原始注解
public A rawAnnotation;
// 代理后新注解
public A proxyAnnotation;
// 向上引用
protected AnnotationProxy<PA, ?> parent;
protected abstract Object invocation(MethodInvocation invocation);
public A newProxy(A annotation) {
return this.newProxy(annotation, null);
}
//创建注解注解代理类
public A newProxy(A annotation, AnnotationProxy<PA, ?> parent) {<FILL_FUNCTION_BODY>}
// annotation method invoke
@SneakyThrows
public Object invoke(MethodInvocation invocation) {
return invocation.getMethod().invoke(invocation.getThis());
}
public <T extends Annotation, R> boolean matchMethod(MethodInvocation invocation, SFunction<T, R> annoLambda) {
return invocation.getMethod().getName().equals(LambdaSee.info(annoLambda).getMethod());
}
}
|
this.parent = parent;
this.rawAnnotation = annotation;
ProxyFactory proxyFactory = new ProxyFactory(annotation);
MethodInterceptor interceptor = this::invocation;
proxyFactory.addAdvice(interceptor);
this.proxyAnnotation = (A) proxyFactory.getProxy(this.getClass().getClassLoader());
return this.proxyAnnotation;
| 264
| 96
| 360
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/AnnotationProxyPool.java
|
AnnotationProxyPool
|
getOrPut
|
class AnnotationProxyPool {
/**
* generic key raw annotation
* generic value proxy annotation
*/
private static final Map<Annotation, Annotation> annotationPool = new HashMap<>();
public static <A extends Annotation> A getOrPut(A rawAnnotation, Function<A, A> function) {<FILL_FUNCTION_BODY>}
}
|
if (annotationPool.containsKey(rawAnnotation)) return (A) annotationPool.get(rawAnnotation);
A proxyAnnotation = function.apply(rawAnnotation);
annotationPool.put(rawAnnotation, proxyAnnotation);
return proxyAnnotation;
| 92
| 60
| 152
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/EruptFieldProxy.java
|
EruptFieldProxy
|
invocation
|
class EruptFieldProxy extends AnnotationProxy<EruptField, Void> {
private static final EruptField tplEruptField;
static {
try {
tplEruptField = EruptTpl.class.getField(EruptField.class.getSimpleName()).getAnnotation(EruptField.class);
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
}
@Override
@SneakyThrows
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, EruptField::views)) {
View[] views = this.rawAnnotation.views();
List<View> proxyViews = new ArrayList<>();
for (View view : views) {
if (ExprInvoke.getExpr(view.ifRender())) {
proxyViews.add(AnnotationProxyPool.getOrPut(view, annotation -> new ViewProxy().newProxy(annotation, this)));
}
}
return proxyViews.toArray(new View[0]);
} else if (super.matchMethod(invocation, EruptField::edit)) {
Edit edit = this.rawAnnotation.edit();
if (ExprInvoke.getExpr(edit.ifRender())) {
return AnnotationProxyPool.getOrPut(edit, annotation -> new EditProxy().newProxy(annotation, this));
} else {
return tplEruptField.edit();
}
}
return this.invoke(invocation);
| 149
| 239
| 388
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.EruptField newProxy(xyz.erupt.annotation.EruptField) ,public xyz.erupt.annotation.EruptField newProxy(xyz.erupt.annotation.EruptField, AnnotationProxy<java.lang.Void,?>) <variables>protected AnnotationProxy<java.lang.Void,?> parent,public xyz.erupt.annotation.EruptField proxyAnnotation,public xyz.erupt.annotation.EruptField rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/EruptProxy.java
|
EruptProxy
|
invocation
|
class EruptProxy extends AnnotationProxy<Erupt, Void> {
@Override
@SneakyThrows
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, Erupt::filter)) {
Filter[] filters = this.rawAnnotation.filter();
Filter[] proxyFilters = new Filter[filters.length];
for (int i = 0; i < filters.length; i++) {
proxyFilters[i] = AnnotationProxyPool.getOrPut(filters[i], filter ->
new FilterProxy<Erupt>().newProxy(filter, this)
);
}
return proxyFilters;
} else if (super.matchMethod(invocation, Erupt::rowOperation)) {
RowOperation[] rowOperations = this.rawAnnotation.rowOperation();
List<RowOperation> proxyOperations = new ArrayList<>();
for (RowOperation rowOperation : rowOperations) {
if (ExprInvoke.getExpr(rowOperation.show())) {
proxyOperations.add(AnnotationProxyPool.getOrPut(rowOperation, it ->
new RowOperationProxy().newProxy(it, this)
));
}
}
return proxyOperations.toArray(new RowOperation[0]);
} else if (super.matchMethod(invocation, Erupt::drills)) {
Drill[] drills = this.rawAnnotation.drills();
List<Drill> proxyDrills = new ArrayList<>();
for (Drill drill : drills) {
if (ExprInvoke.getExpr(drill.show())) {
proxyDrills.add(AnnotationProxyPool.getOrPut(drill, it ->
new DrillProxy().newProxy(it, this)
));
}
}
return proxyDrills.toArray(new Drill[0]);
}
return this.invoke(invocation);
| 59
| 427
| 486
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.Erupt newProxy(xyz.erupt.annotation.Erupt) ,public xyz.erupt.annotation.Erupt newProxy(xyz.erupt.annotation.Erupt, AnnotationProxy<java.lang.Void,?>) <variables>protected AnnotationProxy<java.lang.Void,?> parent,public xyz.erupt.annotation.Erupt proxyAnnotation,public xyz.erupt.annotation.Erupt rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/ProxyContext.java
|
ProxyContext
|
translate
|
class ProxyContext {
private static final ThreadLocal<ProxyContext> proxyContextThreadLocal = ThreadLocal.withInitial(ProxyContext::new);
private Class<?> clazz;
private Field field;
private boolean i18n = false;
public static void set(Class<?> clazz) {
proxyContextThreadLocal.get().setClazz(clazz);
proxyContextThreadLocal.get().setI18n(null != clazz.getAnnotation(EruptI18n.class));
}
public static void set(Field field) {
proxyContextThreadLocal.get().setField(field);
ProxyContext.set(field.getDeclaringClass());
}
public static ProxyContext get() {
return proxyContextThreadLocal.get();
}
public static void remove() {
proxyContextThreadLocal.remove();
}
public static String translate(String key) {<FILL_FUNCTION_BODY>}
}
|
if (ProxyContext.get().i18n) {
return EruptSpringUtil.getBean(I18nTranslate.class).translate(key);
} else {
return key;
}
| 248
| 56
| 304
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt/DrillProxy.java
|
DrillProxy
|
invocation
|
class DrillProxy extends AnnotationProxy<Drill, Erupt> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, Drill::code) && AnnotationConst.EMPTY_STR.equals(this.rawAnnotation.code())) {
return Integer.toString(this.rawAnnotation.title().hashCode());
} else if (super.matchMethod(invocation, Drill::title)) {
return ProxyContext.translate(this.rawAnnotation.title());
}
return this.invoke(invocation);
| 51
| 107
| 158
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_erupt.Drill newProxy(xyz.erupt.annotation.sub_erupt.Drill) ,public xyz.erupt.annotation.sub_erupt.Drill newProxy(xyz.erupt.annotation.sub_erupt.Drill, AnnotationProxy<xyz.erupt.annotation.Erupt,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.Erupt,?> parent,public xyz.erupt.annotation.sub_erupt.Drill proxyAnnotation,public xyz.erupt.annotation.sub_erupt.Drill rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt/FilterProxy.java
|
FilterProxy
|
invocation
|
class FilterProxy<P> extends AnnotationProxy<Filter, P> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, Filter::value)) {
String condition = this.rawAnnotation.value();
if (!this.rawAnnotation.conditionHandler().isInterface()) {
FilterHandler ch = EruptSpringUtil.getBean(this.rawAnnotation.conditionHandler());
condition = ch.filter(condition, this.rawAnnotation.params());
}
return condition;
}
return this.invoke(invocation);
| 51
| 109
| 160
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_erupt.Filter newProxy(xyz.erupt.annotation.sub_erupt.Filter) ,public xyz.erupt.annotation.sub_erupt.Filter newProxy(xyz.erupt.annotation.sub_erupt.Filter, AnnotationProxy<P,?>) <variables>protected AnnotationProxy<P,?> parent,public xyz.erupt.annotation.sub_erupt.Filter proxyAnnotation,public xyz.erupt.annotation.sub_erupt.Filter rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt/RowOperationProxy.java
|
RowOperationProxy
|
invocation
|
class RowOperationProxy extends AnnotationProxy<RowOperation, Erupt> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, RowOperation::code)) {
if (AnnotationConst.EMPTY_STR.equals(this.rawAnnotation.code())) {
return Integer.toString(this.rawAnnotation.title().hashCode());
}
} else if (super.matchMethod(invocation, RowOperation::tip)) {
return ProxyContext.translate(this.rawAnnotation.tip());
} else if (super.matchMethod(invocation, RowOperation::title)) {
return ProxyContext.translate(this.rawAnnotation.title());
} else if (super.matchMethod(invocation, RowOperation::callHint)) {
return I18nTranslate.$translate(this.rawAnnotation.callHint());
}
return this.invoke(invocation);
| 50
| 193
| 243
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_erupt.RowOperation newProxy(xyz.erupt.annotation.sub_erupt.RowOperation) ,public xyz.erupt.annotation.sub_erupt.RowOperation newProxy(xyz.erupt.annotation.sub_erupt.RowOperation, AnnotationProxy<xyz.erupt.annotation.Erupt,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.Erupt,?> parent,public xyz.erupt.annotation.sub_erupt.RowOperation proxyAnnotation,public xyz.erupt.annotation.sub_erupt.RowOperation rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt_field/EditProxy.java
|
EditProxy
|
invocation
|
class EditProxy extends AnnotationProxy<Edit, EruptField> {
@Override
@SneakyThrows
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, Edit::type)) {
if (EditType.AUTO == this.rawAnnotation.type()) {
String returnType = ProxyContext.get().getField().getType().getSimpleName();
if (boolean.class.getSimpleName().equalsIgnoreCase(returnType)) {
return EditType.BOOLEAN;
} else if (TypeUtil.isNumberType(returnType)) {
return EditType.NUMBER;
} else if (EruptUtil.isDateField(returnType)) {
return EditType.DATE;
} else if (ArrayUtils.contains(AnnotationProcess.getEditTypeMapping(EditType.TEXTAREA).nameInfer(), returnType)) {
return EditType.TEXTAREA; //属性名推断
} else {
return EditType.INPUT;
}
}
return this.rawAnnotation.type();
} else if (super.matchMethod(invocation, Edit::filter)) {
Filter[] filters = this.rawAnnotation.filter();
Filter[] proxyFilters = new Filter[filters.length];
for (int i = 0; i < filters.length; i++) {
proxyFilters[i] = AnnotationProxyPool.getOrPut(filters[i], filter -> new FilterProxy<Edit>().newProxy(filter, this));
}
return proxyFilters;
} else if (super.matchMethod(invocation, Edit::readonly)) {
return AnnotationProxyPool.getOrPut(this.rawAnnotation.readonly(), readonly -> new ReadonlyProxy().newProxy(readonly, this));
} else if (super.matchMethod(invocation, Edit::title)) {
return ProxyContext.translate(this.rawAnnotation.title());
} else if (super.matchMethod(invocation, Edit::desc)) {
return ProxyContext.translate(this.rawAnnotation.desc());
} else if (super.matchMethod(invocation, Edit::boolType)) {
return AnnotationProxyPool.getOrPut(this.rawAnnotation.boolType(), boolType -> new BoolTypeProxy().newProxy(boolType, this));
}
return this.invoke(invocation);
| 58
| 541
| 599
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_field.Edit newProxy(xyz.erupt.annotation.sub_field.Edit) ,public xyz.erupt.annotation.sub_field.Edit newProxy(xyz.erupt.annotation.sub_field.Edit, AnnotationProxy<xyz.erupt.annotation.EruptField,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.EruptField,?> parent,public xyz.erupt.annotation.sub_field.Edit proxyAnnotation,public xyz.erupt.annotation.sub_field.Edit rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt_field/ReadonlyProxy.java
|
ReadonlyProxy
|
invocation
|
class ReadonlyProxy extends AnnotationProxy<Readonly, Edit> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
Readonly readonly = this.rawAnnotation;
if (!readonly.exprHandler().isInterface()) {
Readonly.ReadonlyHandler readonlyHandler = EruptSpringUtil.getBean(readonly.exprHandler());
if (super.matchMethod(invocation, Readonly::add)) {
return readonlyHandler.add(readonly.add(), readonly.params());
} else if (super.matchMethod(invocation, Readonly::edit)) {
return readonlyHandler.edit(readonly.edit(), readonly.params());
}
}
return this.invoke(invocation);
| 50
| 142
| 192
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_field.Readonly newProxy(xyz.erupt.annotation.sub_field.Readonly) ,public xyz.erupt.annotation.sub_field.Readonly newProxy(xyz.erupt.annotation.sub_field.Readonly, AnnotationProxy<xyz.erupt.annotation.sub_field.Edit,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.sub_field.Edit,?> parent,public xyz.erupt.annotation.sub_field.Readonly proxyAnnotation,public xyz.erupt.annotation.sub_field.Readonly rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt_field/ViewProxy.java
|
ViewProxy
|
invocation
|
class ViewProxy extends AnnotationProxy<View, EruptField> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, View::type)) {
if (ViewType.AUTO == this.rawAnnotation.type()) {
Edit edit = this.parent.proxyAnnotation.edit();
if (!AnnotationConst.EMPTY_STR.equals(edit.title())) {
switch (edit.type()) {
case ATTACHMENT:
if (edit.attachmentType().type() == AttachmentType.Type.IMAGE) {
return ViewType.IMAGE;
} else {
return ViewType.ATTACHMENT;
}
case CHOICE:
return ViewType.TEXT;
case DATE:
if (edit.dateType().type() == DateType.Type.DATE_TIME) {
return ViewType.DATE_TIME;
} else {
return ViewType.DATE;
}
case HTML_EDITOR:
return ViewType.HTML;
case CODE_EDITOR:
return ViewType.CODE;
case MAP:
return ViewType.MAP;
case TAB_TABLE_ADD:
case TAB_TREE:
case TAB_TABLE_REFER:
case CHECKBOX:
return ViewType.TAB_VIEW;
}
}
String returnType = ProxyContext.get().getField().getType().getSimpleName();
if (boolean.class.getSimpleName().equalsIgnoreCase(returnType.toLowerCase())) {
return ViewType.BOOLEAN;
} else if (EruptUtil.isDateField(returnType)) {
return ViewType.DATE;
} else if (TypeUtil.isNumberType(returnType)) {
return ViewType.NUMBER;
}
return ViewType.TEXT;
}
} else if (super.matchMethod(invocation, View::title)) {
return ProxyContext.translate(this.rawAnnotation.title());
} else if (super.matchMethod(invocation, View::desc)) {
return ProxyContext.translate(this.rawAnnotation.desc());
}
return this.invoke(invocation);
| 50
| 517
| 567
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_field.View newProxy(xyz.erupt.annotation.sub_field.View) ,public xyz.erupt.annotation.sub_field.View newProxy(xyz.erupt.annotation.sub_field.View, AnnotationProxy<xyz.erupt.annotation.EruptField,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.EruptField,?> parent,public xyz.erupt.annotation.sub_field.View proxyAnnotation,public xyz.erupt.annotation.sub_field.View rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/proxy/erupt_field/type/BoolTypeProxy.java
|
BoolTypeProxy
|
invocation
|
class BoolTypeProxy extends AnnotationProxy<BoolType, Edit> {
@Override
protected Object invocation(MethodInvocation invocation) {<FILL_FUNCTION_BODY>}
}
|
if (super.matchMethod(invocation, BoolType::trueText)) {
return I18nTranslate.$translate(this.rawAnnotation.trueText());
} else if (super.matchMethod(invocation, BoolType::falseText)) {
return I18nTranslate.$translate(this.rawAnnotation.falseText());
}
return this.invoke(invocation);
| 51
| 100
| 151
|
<methods>public non-sealed void <init>() ,public java.lang.Object invoke(MethodInvocation) ,public boolean matchMethod(MethodInvocation, SFunction<T,R>) ,public xyz.erupt.annotation.sub_field.sub_edit.BoolType newProxy(xyz.erupt.annotation.sub_field.sub_edit.BoolType) ,public xyz.erupt.annotation.sub_field.sub_edit.BoolType newProxy(xyz.erupt.annotation.sub_field.sub_edit.BoolType, AnnotationProxy<xyz.erupt.annotation.sub_field.Edit,?>) <variables>protected AnnotationProxy<xyz.erupt.annotation.sub_field.Edit,?> parent,public xyz.erupt.annotation.sub_field.sub_edit.BoolType proxyAnnotation,public xyz.erupt.annotation.sub_field.sub_edit.BoolType rawAnnotation
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/service/EruptApplication.java
|
EruptApplication
|
registerBeanDefinitions
|
class EruptApplication implements ImportBeanDefinitionRegistrar {
private static Class<?> primarySource;
private static final Set<String> scanPackage = new HashSet<>();
public static Class<?> getPrimarySource() {
return primarySource;
}
public static String[] getScanPackage() {
return scanPackage.toArray(new String[0]);
}
@SneakyThrows
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {<FILL_FUNCTION_BODY>}
}
|
Class<?> clazz = ClassUtils.forName(importingClassMetadata.getClassName(), ClassUtils.getDefaultClassLoader());
Optional.ofNullable(clazz.getAnnotation(SpringBootApplication.class)).ifPresent(it -> primarySource = clazz);
EruptScan eruptScan = clazz.getAnnotation(EruptScan.class);
try {
Class.forName("org.springframework.boot.devtools.RemoteUrlPropertyExtractor");
log.error("spring-boot-devtools 与 erupt 同时存在会出现各种奇怪的问题，建议移除该依赖！！！");
} catch (ClassNotFoundException ignored) {
}
if (eruptScan.value().length == 0) {
scanPackage.add(clazz.getPackage().getName());
} else {
Stream.of(eruptScan.value()).filter(pack -> !pack.equals(EruptConst.BASE_PACKAGE)).forEach(scanPackage::add);
}
| 146
| 241
| 387
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/service/EruptCoreService.java
|
EruptCoreService
|
initEruptModel
|
class EruptCoreService implements ApplicationRunner {
private static final Map<String, EruptModel> ERUPTS = new LinkedCaseInsensitiveMap<>();
private static final List<EruptModel> ERUPT_LIST = new ArrayList<>();
private static final List<String> MODULES = new ArrayList<>();
public static List<String> getModules() {
return MODULES;
}
public static List<EruptModel> getErupts() {
return ERUPT_LIST;
}
public static EruptModel getErupt(String eruptName) {
return ERUPTS.get(eruptName);
}
//动态注册erupt类
public static void registerErupt(Class<?> eruptClazz) {
if (ERUPTS.containsKey(eruptClazz.getSimpleName())) {
throw new RuntimeException(eruptClazz.getSimpleName() + " conflict !");
}
EruptModel eruptModel = initEruptModel(eruptClazz);
ERUPTS.put(eruptClazz.getSimpleName(), eruptModel);
ERUPT_LIST.add(eruptModel);
}
//移除容器内所维护的Erupt
public static void unregisterErupt(Class<?> eruptClazz) {
ERUPTS.remove(eruptClazz.getSimpleName());
ERUPT_LIST.removeIf(model -> model.getEruptName().equals(eruptClazz.getSimpleName()));
}
@SneakyThrows
public static EruptModel getEruptView(String eruptName) {
EruptModel em = getErupt(eruptName).clone();
for (EruptFieldModel fieldModel : em.getEruptFieldModels()) {
Edit edit = fieldModel.getEruptField().edit();
if (edit.type() == EditType.CHOICE) {
fieldModel.setComponentValue(EruptUtil.getChoiceList(em, edit.choiceType()));
} else if (edit.type() == EditType.TAGS) {
fieldModel.setComponentValue(EruptUtil.getTagList(edit.tagsType()));
}
}
return em;
}
private static EruptModel initEruptModel(Class<?> clazz) {<FILL_FUNCTION_BODY>}
@Override
public void run(ApplicationArguments args) {
TimeRecorder totalRecorder = new TimeRecorder();
TimeRecorder timeRecorder = new TimeRecorder();
EruptSpringUtil.scannerPackage(EruptApplication.getScanPackage(), new TypeFilter[]{
new AnnotationTypeFilter(Erupt.class)
}, clazz -> {
EruptModel eruptModel = initEruptModel(clazz);
ERUPTS.put(clazz.getSimpleName(), eruptModel);
ERUPT_LIST.add(eruptModel);
});
log.info("<" + repeat("===", 20) + ">");
AtomicInteger moduleMaxCharLength = new AtomicInteger();
EruptModuleInvoke.invoke(it -> {
int length = it.info().getName().length();
if (length > moduleMaxCharLength.get()) moduleMaxCharLength.set(length);
});
EruptModuleInvoke.invoke(it -> {
it.run();
MODULES.add(it.info().getName());
log.info("🚀 -> {} module initialization completed in {}ms", fillCharacter(it.info().getName(),
moduleMaxCharLength.get()), timeRecorder.recorder()
);
});
log.info("Erupt modules : " + MODULES.size());
log.info("Erupt classes : " + ERUPTS.size());
log.info("Erupt Framework initialization completed in {}ms", totalRecorder.recorder());
log.info("<" + repeat("===", 20) + ">");
}
private String fillCharacter(String character, int targetWidth) {
return character + repeat(" ", targetWidth - character.length());
}
private String repeat(String space, int num) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < num; i++) sb.append(space);
return sb.toString();
}
}
|
// erupt class data to memory
EruptModel eruptModel = new EruptModel(clazz);
// erupt field data to memory
eruptModel.setEruptFieldModels(new ArrayList<>());
eruptModel.setEruptFieldMap(new LinkedCaseInsensitiveMap<>());
ReflectUtil.findClassAllFields(clazz, field -> Optional.ofNullable(field.getAnnotation(EruptField.class))
.ifPresent(ignore -> {
EruptFieldModel eruptFieldModel = new EruptFieldModel(field);
eruptModel.getEruptFieldModels().add(eruptFieldModel);
if (!eruptModel.getEruptFieldMap().containsKey(field.getName())) {
eruptModel.getEruptFieldMap().put(field.getName(), eruptFieldModel);
}
})
);
eruptModel.getEruptFieldModels().sort(Comparator.comparingInt((a) -> a.getEruptField().sort()));
// erupt annotation validate
EruptAnnotationException.validateEruptInfo(eruptModel);
return eruptModel;
| 1,081
| 274
| 1,355
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/service/EruptService.java
|
EruptService
|
getEruptData
|
class EruptService {
@Resource
private HttpServletRequest request;
/**
* @param eruptModel eruptModel
* @param tableQuery 前端查询对象
* @param serverCondition 自定义条件
* @param customCondition 条件字符串
*/
public Page getEruptData(EruptModel eruptModel, TableQuery tableQuery, List<Condition> serverCondition, String... customCondition) {<FILL_FUNCTION_BODY>}
@SneakyThrows
public void drillProcess(EruptModel eruptModel, BiConsumer<Link, Object> consumer) {
String drill = request.getHeader(EruptReqHeader.DRILL);
if (null != drill) {
String drillValue = request.getHeader(EruptReqHeader.DRILL_VALUE);
String sourceErupt = request.getHeader(EruptReqHeader.DRILL_SOURCE_ERUPT);
if (null == drillValue || null == sourceErupt) {
throw new EruptWebApiRuntimeException("Drill Header Illegal ，Lack：" + EruptReqHeader.DRILL_VALUE + "," + EruptReqHeader.DRILL_SOURCE_ERUPT);
}
EruptModel sourceModel = EruptCoreService.getErupt(sourceErupt);
Link link = Stream.of(sourceModel.getErupt().drills()).filter(it -> drill.equals(it.code()))
.findFirst().orElseThrow(EruptNoLegalPowerException::new).link();
if (!link.linkErupt().getSimpleName().equals(eruptModel.getEruptName())) {
throw new EruptWebApiRuntimeException("Illegal erupt from " + drill);
}
Object data = DataProcessorManager.getEruptDataProcessor(sourceModel.getClazz()).findDataById(sourceModel, EruptUtil.toEruptId(sourceModel, drillValue));
Field field = ReflectUtil.findClassField(sourceModel.getClazz(), link.column());
field.setAccessible(true);
Object val = field.get(data);
consumer.accept(link, val);
}
}
/**
* 校验id使用权限
*
* @param eruptModel eruptModel
* @param id 标识主键
*/
public void verifyIdPermissions(EruptModel eruptModel, String id) {
List<Condition> conditions = new ArrayList<>();
conditions.add(new Condition(eruptModel.getErupt().primaryKeyCol(), id, QueryExpression.EQ));
Page page = DataProcessorManager.getEruptDataProcessor(eruptModel.getClazz())
.queryList(eruptModel, new Page(1, 1),
EruptQuery.builder().conditions(conditions).build());
if (page.getList().isEmpty()) {
throw new EruptNoLegalPowerException();
}
}
}
|
Erupts.powerLegal(eruptModel, PowerObject::isQuery);
List<Condition> legalConditions = EruptUtil.geneEruptSearchCondition(eruptModel, tableQuery.getCondition());
List<String> conditionStrings = new ArrayList<>();
//DependTree logic
LinkTree dependTree = eruptModel.getErupt().linkTree();
if (StringUtils.isNotBlank(dependTree.field())) {
if (null == tableQuery.getLinkTreeVal()) {
if (dependTree.dependNode()) return new Page();
} else {
EruptModel treeErupt = EruptCoreService.getErupt(ReflectUtil.findClassField(eruptModel.getClazz(), dependTree.field()).getType().getSimpleName());
EruptFieldModel pk = treeErupt.getEruptFieldMap().get(treeErupt.getErupt().primaryKeyCol());
if (pk.getField().getType() == String.class) {
conditionStrings.add(String.format("%s = '%s'", dependTree.field() + EruptConst.DOT + pk.getFieldName(), tableQuery.getLinkTreeVal()));
} else {
conditionStrings.add(String.format("%s = %s", dependTree.field() + EruptConst.DOT + pk.getFieldName(), tableQuery.getLinkTreeVal()));
}
}
}
Layout layout = eruptModel.getErupt().layout();
if (Layout.PagingType.FRONT == layout.pagingType() || Layout.PagingType.NONE == layout.pagingType()) {
tableQuery.setPageSize(layout.pageSizes()[layout.pageSizes().length - 1]);
}
this.drillProcess(eruptModel, (link, val) -> conditionStrings.add(String.format(val instanceof String ? "%s = '%s'" : "%s = %s", link.linkErupt().getSimpleName() + EruptConst.DOT + link.joinColumn(), val)));
conditionStrings.addAll(Arrays.asList(customCondition));
DataProxyInvoke.invoke(eruptModel, (dataProxy -> Optional.ofNullable(dataProxy.beforeFetch(legalConditions)).ifPresent(conditionStrings::add)));
Optional.ofNullable(serverCondition).ifPresent(legalConditions::addAll);
Page page = DataProcessorManager.getEruptDataProcessor(eruptModel.getClazz())
.queryList(eruptModel, tableQuery, EruptQuery.builder().orderBy(tableQuery.getSort())
.conditionStrings(conditionStrings).conditions(legalConditions).build());
DataProxyInvoke.invoke(eruptModel, (dataProxy -> dataProxy.afterFetch(page.getList())));
Optional.ofNullable(page.getList()).ifPresent(it -> DataHandlerUtil.convertDataToEruptView(eruptModel, it));
return page;
| 733
| 722
| 1,455
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/service/PreEruptDataService.java
|
PreEruptDataService
|
createColumnQuery
|
class PreEruptDataService {
/**
* 根据要素生成树结构
*
* @param eruptModel eruptModel
* @param id id
* @param label label
* @param pid parent id
* @param query 查询对象
* @return 树对象
*/
public Collection<TreeModel> geneTree(EruptModel eruptModel, String id, String label, String pid, Expr rootId, EruptQuery query) {
List<Column> columns = new ArrayList<>();
columns.add(new Column(id, AnnotationConst.ID));
columns.add(new Column(label, AnnotationConst.LABEL));
if (!AnnotationConst.EMPTY_STR.equals(pid)) {
columns.add(new Column(pid, AnnotationConst.PID));
}
Collection<Map<String, Object>> result = this.createColumnQuery(eruptModel, columns, query);
String root = ExprInvoke.getExpr(rootId);
List<TreeModel> treeModels = new ArrayList<>();
result.forEach(it -> treeModels.add(new TreeModel(
it.get(AnnotationConst.ID), it.get(AnnotationConst.LABEL), it.get(AnnotationConst.PID), root
)));
if (StringUtils.isBlank(pid)) {
return treeModels;
} else {
return DataHandlerUtil.quoteTree(treeModels);
}
}
public Collection<Map<String, Object>> createColumnQuery(EruptModel eruptModel, List<Column> columns, EruptQuery query) {<FILL_FUNCTION_BODY>}
}
|
List<String> conditionStrings = new ArrayList<>();
DataProxyInvoke.invoke(eruptModel, (dataProxy -> {
String condition = dataProxy.beforeFetch(query.getConditions());
if (StringUtils.isNotBlank(condition)) {
conditionStrings.add(condition);
}
}));
for (Filter filter : eruptModel.getErupt().filter()) {
conditionStrings.add(filter.value());
}
Optional.ofNullable(query.getConditionStrings()).ifPresent(conditionStrings::addAll);
conditionStrings.removeIf(Objects::isNull);
String orderBy = StringUtils.isNotBlank(query.getOrderBy()) ? query.getOrderBy() : eruptModel.getErupt().orderBy();
Collection<Map<String, Object>> result = DataProcessorManager.getEruptDataProcessor(eruptModel.getClazz())
.queryColumn(eruptModel, columns, EruptQuery.builder()
.conditions(query.getConditions()).conditionStrings(conditionStrings).orderBy(orderBy).build());
DataProxyInvoke.invoke(eruptModel, (dataProxy -> dataProxy.afterFetch(result)));
return result;
| 414
| 303
| 717
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/toolkit/TimeRecorder.java
|
TimeRecorder
|
recorder
|
class TimeRecorder {
private Long current;
public TimeRecorder() {
this.current = System.currentTimeMillis();
}
public synchronized long recorder() {<FILL_FUNCTION_BODY>}
}
|
try {
return System.currentTimeMillis() - this.current;
} finally {
this.current = System.currentTimeMillis();
}
| 64
| 43
| 107
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/CloneSupport.java
|
CloneSupport
|
clone
|
class CloneSupport<T> implements Cloneable {
@Override
public T clone() {<FILL_FUNCTION_BODY>}
}
|
try {
return (T) super.clone();
} catch (Exception e) {
throw new RuntimeException(e);
}
| 40
| 38
| 78
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/DataHandlerUtil.java
|
DataHandlerUtil
|
convertColumnValue
|
class DataHandlerUtil {
// 引用方式 生成树结构数据
public static List<TreeModel> quoteTree(List<TreeModel> treeModels) {
Map<String, TreeModel> treeModelMap = new LinkedHashMap<>(treeModels.size());
treeModels.forEach(treeModel -> treeModelMap.put(treeModel.getId(), treeModel));
List<TreeModel> resultTreeModels = new ArrayList<>();
treeModels.forEach(treeModel -> {
if (treeModel.isRoot()) {
treeModel.setLevel(1);
resultTreeModels.add(treeModel);
return;
}
Optional.ofNullable(treeModelMap.get(treeModel.getPid())).ifPresent(parentTreeModel -> {
Collection<TreeModel> children = CollectionUtils.isEmpty(parentTreeModel.getChildren()) ? new ArrayList<>() : parentTreeModel.getChildren();
children.add(treeModel);
children.forEach(child -> child.setLevel(Optional.ofNullable(parentTreeModel.getLevel()).orElse(1) + 1));
parentTreeModel.setChildren(children);
});
});
return resultTreeModels;
}
private static EruptFieldModel cycleFindFieldByKey(EruptModel eruptModel, String key) {
EruptFieldModel fieldModel = eruptModel.getEruptFieldMap().get(key);
if (null != fieldModel) {
return fieldModel;
}
if (key.contains("_")) {
return cycleFindFieldByKey(eruptModel, key.substring(0, key.lastIndexOf("_")));
}
return null;
}
public static void convertDataToEruptView(EruptModel eruptModel, Collection<Map<String, Object>> list) {
Map<String, Map<String, String>> choiceItems = new HashMap<>();
for (Map<String, Object> map : list) {
for (Map.Entry<String, Object> entry : map.entrySet()) {
EruptFieldModel fieldModel = cycleFindFieldByKey(eruptModel, entry.getKey());
if (null == fieldModel) {
continue;
}
Edit edit = fieldModel.getEruptField().edit();
switch (edit.type()) {
case REFERENCE_TREE:
case REFERENCE_TABLE:
case COMBINE:
String[] _keys = entry.getKey().split("_");
for (View view : fieldModel.getEruptField().views()) {
if (view.column().equals(_keys[_keys.length - 1])) {
EruptFieldModel vef = EruptCoreService.getErupt(fieldModel.getFieldReturnName()).getEruptFieldMap().get(view.column());
map.put(entry.getKey(), convertColumnValue(eruptModel, vef, entry.getValue(), choiceItems));
}
}
break;
default:
map.put(entry.getKey(), convertColumnValue(eruptModel, fieldModel, entry.getValue(), choiceItems));
break;
}
}
}
}
private static Object convertColumnValue(EruptModel eruptModel, EruptFieldModel fieldModel, Object value, Map<String, Map<String, String>> choiceItems) {<FILL_FUNCTION_BODY>}
}
|
if (null == value) return null;
Edit edit = fieldModel.getEruptField().edit();
switch (edit.type()) {
case CHOICE:
Map<String, String> cm = choiceItems.get(fieldModel.getFieldName());
if (null == cm) {
cm = EruptUtil.getChoiceMap(eruptModel, edit.choiceType());
choiceItems.put(fieldModel.getFieldName(), cm);
}
return cm.get(value.toString());
case BOOLEAN:
return (Boolean) value ? edit.boolType().trueText() : edit.boolType().falseText();
}
return value;
| 826
| 169
| 995
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/DateUtil.java
|
DateUtil
|
getDate
|
class DateUtil {
public static final String DATE = "yyyy-MM-dd";
public static final String DATE_TIME = "yyyy-MM-dd HH:mm:ss";
public static String getSimpleFormatDateTime(Date date) {
return getFormatDate(date, DATE_TIME);
}
public static String getSimpleFormatDate(Date date) {
return getFormatDate(date, DATE);
}
public static String getFormatDate(Date date, String formatStr) {
SimpleDateFormat sdf = new SimpleDateFormat(formatStr);
return sdf.format(date);
}
@SneakyThrows
public static Object getDate(Class<?> targetDateType, String str) {<FILL_FUNCTION_BODY>}
}
|
if (targetDateType == Date.class) {
if (str.length() == 10) {
return new SimpleDateFormat(DATE).parse(str);
} else {
return new SimpleDateFormat(DATE_TIME).parse(str);
}
} else if (targetDateType == LocalDate.class) {
return LocalDate.parse(str, DateTimeFormatter.ofPattern(DATE));
} else if (targetDateType == LocalDateTime.class) {
return LocalDateTime.parse(str, DateTimeFormatter.ofPattern(DATE_TIME));
} else {
throw new EruptWebApiRuntimeException("Unsupported date type");
}
| 202
| 163
| 365
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/EruptAssert.java
|
EruptAssert
|
notNull
|
class EruptAssert {
public static void notNull(Object[] arr, String message) {<FILL_FUNCTION_BODY>}
}
|
if (null == arr || arr.length == 0) {
throw new IllegalArgumentException(message);
}
| 38
| 30
| 68
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/EruptSpringUtil.java
|
EruptSpringUtil
|
getBean
|
class EruptSpringUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (EruptSpringUtil.applicationContext == null) {
EruptSpringUtil.applicationContext = applicationContext;
}
}
//获取applicationContext
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
//通过class获取Bean.
@SneakyThrows
public static <T> T getBean(Class<T> clazz) {<FILL_FUNCTION_BODY>}
//通过name,以及Clazz返回指定的Bean
public static <T> T getProperty(String key, Class<T> clazz) {
return getApplicationContext().getEnvironment().getProperty(key, clazz);
}
//通过name,以及Clazz返回指定的Bean
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
//根据类路径获取bean
public static <T> T getBeanByPath(String path, Class<T> clazz) throws ClassNotFoundException {
return clazz.cast(getBean(Class.forName(path)));
}
/**
* 按照相对应的规则查找所有匹配类
*
* @param packages 包名
* @param typeFilters 匹配规则
* @param consumer consumer lambda
*/
@SneakyThrows
public static void scannerPackage(String[] packages, TypeFilter[] typeFilters, Consumer<Class<?>> consumer) {
ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
for (TypeFilter filter : typeFilters) {
scanner.addIncludeFilter(filter);
}
for (String pack : packages) {
for (BeanDefinition bd : scanner.findCandidateComponents(pack)) {
consumer.accept(Class.forName(bd.getBeanClassName()));
}
}
}
}
|
if (null != clazz.getDeclaredAnnotation(Component.class)
|| null != clazz.getDeclaredAnnotation(Service.class)
|| null != clazz.getDeclaredAnnotation(Repository.class)
|| null != clazz.getDeclaredAnnotation(RestController.class)
|| null != clazz.getDeclaredAnnotation(Controller.class)) {
return getApplicationContext().getBean(clazz);
} else {
return clazz.newInstance();
}
| 537
| 126
| 663
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/MD5Util.java
|
MD5Util
|
byteToArrayString
|
class MD5Util {
private final static String[] STR_DIGITS = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
private static String byteToArrayString(byte bByte) {<FILL_FUNCTION_BODY>}
private static String byteToString(byte[] bByte) {
StringBuilder sb = new StringBuilder();
for (byte b : bByte) {
sb.append(byteToArrayString(b));
}
return sb.toString();
}
public static String digest(String strObj) {
return digest(strObj, StandardCharsets.UTF_8.name());
}
public static String digest(String strObj, String charset) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
return byteToString(md.digest(strObj.getBytes(charset)));
} catch (Exception ex) {
return strObj;
}
}
// str -> md5str -> md5(md5str + salt )-> md5salt
public static String digestSalt(String strObj, String salt) {
strObj = digest(strObj);
strObj += salt;
return digest(strObj);
}
}
|
int iRet = bByte;
if (iRet < 0) {
iRet += 256;
}
int iD1 = iRet / 16;
int iD2 = iRet % 16;
return STR_DIGITS[iD1] + STR_DIGITS[iD2];
| 345
| 88
| 433
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/MimeUtil.java
|
MimeUtil
|
getMimeType
|
class MimeUtil {
private static final Properties mimes = new Properties();
static {
try (InputStream in = MimeUtil.class.getClassLoader().getResourceAsStream("mime.properties")) {
mimes.load(in);
} catch (IOException e) {
log.warn("mime file load error", e);
}
}
public static String getMimeType(String fileName) {<FILL_FUNCTION_BODY>}
}
|
String[] nameSplits = fileName.split("\\.");
String type = mimes.getProperty(nameSplits[nameSplits.length - 1]);
if (StringUtils.isBlank(type)) {
type = MediaType.APPLICATION_OCTET_STREAM_VALUE;
}
return type;
| 121
| 88
| 209
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/ProjectUtil.java
|
ProjectUtil
|
projectStartLoaded
|
class ProjectUtil {
private static final String LOADED_EXT = ".loaded";
/**
* @param projectName 标识名
* @param first bool回调，表示函数是否为第一次调用
*/
@SneakyThrows
public void projectStartLoaded(String projectName, Consumer<Boolean> first) {<FILL_FUNCTION_BODY>}
}
|
String userDir = System.getProperty("user.dir");
File dirFile = new File(userDir, EruptConst.ERUPT_DIR);
String warnTxt = " The erupt initialization ID file could not be created";
if (!dirFile.exists() && !dirFile.mkdirs()) {
log.warn(dirFile + warnTxt);
}
File file = new File(dirFile.getPath(), projectName + LOADED_EXT);
if (file.exists()) {
first.accept(false);
} else {
first.accept(true);
if (file.createNewFile()) {
FileUtils.writeStringToFile(file, EruptInformation.getEruptVersion(), StandardCharsets.UTF_8.name());
} else {
log.warn(dirFile + warnTxt);
}
}
| 103
| 213
| 316
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/ReflectUtil.java
|
ReflectUtil
|
findFieldChain
|
class ReflectUtil {
//递归查找类字段
public static Field findClassField(Class<?> clazz, String fieldName) {
Field field;
while (clazz != null) {
try {
field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
return field;
} catch (NoSuchFieldException e) {
if (Object.class.equals(clazz = clazz.getSuperclass())) {
break;
}
}
}
return null;
}
public static Object findFieldChain(String fieldName, Object obj)
throws IllegalAccessException {<FILL_FUNCTION_BODY>}
public static void findClassAllFields(Class<?> clazz, Consumer<Field> fieldConsumer) {
Class<?> tempClass = clazz;
while (null != tempClass) {
for (Field field : tempClass.getDeclaredFields()) {
int mod = field.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isInterface(mod)) {
continue;
}
fieldConsumer.accept(field);
}
tempClass = tempClass.getSuperclass();
}
}
//获取继承列表
public static List<Class<?>> findClassExtendStack(Class<?> clazz) {
List<Class<?>> list = new ArrayList<>();
Class<?> tempClass = clazz;
while (null != tempClass) {
tempClass = tempClass.getSuperclass();
if (tempClass != null && tempClass != Object.class) {
list.add(tempClass);
}
}
if (list.size() > 1) {
Collections.reverse(list);
}
return list;
}
//获取字段泛型名
public static List<String> getFieldGenericName(Field field) {
List<String> names = new ArrayList<>();
Type gType = field.getGenericType();
if (gType instanceof ParameterizedType) {
Type[] typeArguments = ((ParameterizedType) gType).getActualTypeArguments();
for (Type typeArgument : typeArguments) {
String[] gArray = typeArgument.getTypeName().split("\\.");
names.add(gArray[gArray.length - 1]);
}
}
return names;
}
}
|
String[] fields = fieldName.split("\\.");
for (String field : fields) {
Field f = findClassField(obj.getClass(), field);
if (f == null) {
throw new RuntimeException(obj.getClass().getName() + EruptConst.DOT + fieldName + " not found");
}
if (null == (obj = f.get(obj))) {
return null;
}
}
return obj;
| 611
| 115
| 726
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/SecretUtil.java
|
SecretUtil
|
decodeSecret
|
class SecretUtil {
public static String decodeSecret(String str) {
return decodeSecret(str, 1);
}
/**
* 解密Base64
*
* @param str 加密字符串
* @param encodeNum 被加密了几次
* @return 原文
*/
@SneakyThrows
public static String decodeSecret(String str, int encodeNum) {<FILL_FUNCTION_BODY>}
}
|
for (int i = 0; i < encodeNum; i++) {
str = new String(Base64.getDecoder().decode(str));
}
return URLDecoder.decode(str, StandardCharsets.UTF_8.name());
| 128
| 64
| 192
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/SecurityUtil.java
|
SecurityUtil
|
xssInspect
|
class SecurityUtil {
// xss跨站脚本检测
public static boolean xssInspect(String value) {<FILL_FUNCTION_BODY>}
//检测 跨站请求伪造
public static boolean csrfInspect(HttpServletRequest request, HttpServletResponse response) {
String origin = request.getHeader("Origin");
if (null != origin && !origin.contains(request.getHeader("Host"))) {
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
response.setContentType("text/plain; charset=utf-8");
try (PrintWriter out = response.getWriter()) {
String text = "Illegal cross-site request!";
out.append(text);
throw new EruptWebApiRuntimeException(text);
} catch (IOException e) {
log.error("csrf inspect error", e);
}
return true;
}
return false;
}
}
|
if (StringUtils.isNotBlank(value)) {
// 避免script 标签
Pattern scriptPattern = Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免src形式的表达式
scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\'(.*?)\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 删除单个的<script ...> 标签
scriptPattern = Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 eval(...) 形式表达式
scriptPattern = Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 expression(...) 表达式
scriptPattern = Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 javascript: 表达式
scriptPattern = Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 vbscript: 表达式
scriptPattern = Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 onload= 表达式
scriptPattern = Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 onmouseover= 表达式
scriptPattern = Pattern.compile("onmouseover(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 onfocus= 表达式
scriptPattern = Pattern.compile("onfocus(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
if (scriptPattern.matcher(value).find()) {
return true;
}
// 避免 onerror= 表达式
scriptPattern = Pattern.compile("^onerror(.*?)=$", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
return scriptPattern.matcher(value).find();
}
return false;
| 238
| 921
| 1,159
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/util/TypeUtil.java
|
TypeUtil
|
typeStrConvertObject
|
class TypeUtil {
private static final String[] SIMPLE_JPA_TYPE = {
"byte", "short", "int", "integer", "long", "float", "double", "boolean", "char", "String", "date", "character", "char"
};
private static final String[] NUMBER_TYPE = {
"short", "int", "integer", "long", "float", "double", "bigdecimal", "biginteger"
};
/**
* 将未知类型转换为目标类型
*/
@SneakyThrows
public static Object typeStrConvertObject(Object obj, Class<?> targetType) {<FILL_FUNCTION_BODY>}
public static void simpleNumberTypeArrayToObject(Object obj, String type, Consumer<Number> consumer) {
if (int.class.getSimpleName().equals(type)) {
for (Number i : (int[]) obj) {
consumer.accept(i);
}
} else if (short.class.getSimpleName().equals(type)) {
for (Number i : (short[]) obj) {
consumer.accept(i);
}
} else if (long.class.getSimpleName().equals(type)) {
for (Number i : (long[]) obj) {
consumer.accept(i);
}
} else if (float.class.getSimpleName().equals(type)) {
for (Number i : (float[]) obj) {
consumer.accept(i);
}
} else if (double.class.getSimpleName().equals(type)) {
for (Number i : (double[]) obj) {
consumer.accept(i);
}
}
}
// 判断实体类字段返回值是否为基本类型（包括String与date）
public static boolean isFieldSimpleType(String typeName) {
return Arrays.asList(SIMPLE_JPA_TYPE).contains(typeName.toLowerCase());
}
public static boolean isNumberType(String typeName) {
return Arrays.asList(NUMBER_TYPE).contains(typeName.toLowerCase());
}
//判断是否为数值类型
public static boolean isNumber(Object obj) {
return obj instanceof Number || NumberUtils.isCreatable(obj.toString());
}
}
|
String str = obj.toString();
if (NumberUtils.isCreatable(str)) {
if (str.endsWith(".0")) { //处理gson序列化数值多了一个0
str = str.substring(0, str.length() - 2);
}
}
if (int.class == targetType || Integer.class == targetType) {
return Integer.valueOf(str);
} else if (short.class == targetType || Short.class == targetType) {
return Short.valueOf(str);
} else if (long.class == targetType || Long.class == targetType) {
return Long.valueOf(str);
} else if (float.class == targetType || Float.class == targetType) {
return Float.valueOf(str);
} else if (double.class == targetType || Double.class == targetType) {
return Double.valueOf(str);
} else if (BigDecimal.class == targetType) {
return new BigDecimal(str);
} else if (boolean.class == targetType || Boolean.class == targetType) {
return Boolean.valueOf(str);
} else if (targetType.isEnum()) {
return targetType.getMethod("valueOf", String.class).invoke(targetType, str);
} else {
return str;
}
| 581
| 337
| 918
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/view/EruptApiModel.java
|
EruptApiModel
|
errorNoInterceptApi
|
class EruptApiModel {
private Status status;
private PromptWay promptWay;
private String message;
private Object data;
private boolean errorIntercept = true;
public EruptApiModel(Status status, String message, Object data, PromptWay promptWay) {
this.status = status;
this.message = message;
this.data = data;
this.promptWay = promptWay;
}
public EruptApiModel(Status status, String message, PromptWay promptWay) {
this.status = status;
this.message = message;
this.promptWay = promptWay;
}
public static EruptApiModel successApi() {
return new EruptApiModel(Status.SUCCESS, null, null, PromptWay.MESSAGE);
}
public static EruptApiModel successApi(String message, Object data) {
return new EruptApiModel(Status.SUCCESS, message, data, PromptWay.MESSAGE);
}
public static EruptApiModel successApi(Object data) {
return new EruptApiModel(Status.SUCCESS, null, data, PromptWay.MESSAGE);
}
public static EruptApiModel errorApi(String message) {
return new EruptApiModel(Status.ERROR, message, null, PromptWay.DIALOG);
}
public static EruptApiModel errorNoInterceptApi(String message) {<FILL_FUNCTION_BODY>}
public static EruptApiModel errorNoInterceptMessage(String message) {
EruptApiModel eruptApiModel = new EruptApiModel(Status.ERROR, message, null, PromptWay.MESSAGE);
eruptApiModel.errorIntercept = false;
return eruptApiModel;
}
public static EruptApiModel errorApi(Exception e) {
return new EruptApiModel(Status.ERROR, e.getMessage(), null, PromptWay.DIALOG);
}
public enum Status {
SUCCESS, ERROR, INFO, WARNING
}
public enum PromptWay {
DIALOG, MESSAGE, NOTIFY, NONE
}
}
|
EruptApiModel eruptApiModel = new EruptApiModel(Status.ERROR, message, null, PromptWay.DIALOG);
eruptApiModel.errorIntercept = false;
return eruptApiModel;
| 573
| 59
| 632
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/view/EruptModel.java
|
EruptModel
|
clone
|
class EruptModel implements Cloneable {
private transient Class<?> clazz;
private transient Erupt erupt;
private transient AnnotationProxy<Erupt, Void> eruptAnnotationProxy = new EruptProxy();
private transient Map<String, EruptFieldModel> eruptFieldMap;
private transient boolean i18n;
private String eruptName;
private JsonObject eruptJson;
private List<EruptFieldModel> eruptFieldModels;
//默认查询条件
private Map<String, Object> searchCondition;
private boolean extraRow = false;
public EruptModel(Class<?> eruptClazz) {
this.clazz = eruptClazz;
this.erupt = eruptClazz.getAnnotation(Erupt.class);
this.erupt = eruptAnnotationProxy.newProxy(this.getErupt());
this.eruptName = eruptClazz.getSimpleName();
this.i18n = null != clazz.getAnnotation(EruptI18n.class);
DataProxyInvoke.invoke(this, it -> {
try {
it.getClass().getDeclaredMethod("extraRow", List.class);
this.extraRow = true;
} catch (NoSuchMethodException ignored) {
}
});
}
public Erupt getErupt() {
ProxyContext.set(clazz);
return erupt;
}
@Override
public EruptModel clone() throws CloneNotSupportedException {<FILL_FUNCTION_BODY>}
}
|
EruptModel eruptModel = (EruptModel) super.clone();
eruptModel.eruptJson = AnnotationProcess.annotationToJsonByReflect(this.getErupt());
eruptModel.eruptFieldModels = eruptFieldModels.stream().map(CloneSupport::clone)
.peek(EruptFieldModel::serializable).collect(Collectors.toList());
return eruptModel;
| 403
| 103
| 506
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.