/** Return the indexes available for this field (for repeated fields ad List) */
public List<Integer> indexes() {
List<Integer> result = new ArrayList<Integer>();
if (form.value().isDefined()) {
BeanWrapper beanWrapper = new BeanWrapperImpl(form.value().get());
beanWrapper.setAutoGrowNestedPaths(true);
String objectKey = name;
if (form.name() != null && name.startsWith(form.name() + ".")) {
objectKey = name.substring(form.name().length() + 1);
}
if (beanWrapper.isReadableProperty(objectKey)) {
Object value = beanWrapper.getPropertyValue(objectKey);
if (value instanceof Collection) {
for (int i = 0; i < ((Collection) value).size(); i++) {
result.add(i);
}
}
}
} else {
java.util.regex.Pattern pattern =
java.util.regex.Pattern.compile(
"^" + java.util.regex.Pattern.quote(name) + "\\[(\\d+)\\].*$");
for (String key : form.data().keySet()) {
java.util.regex.Matcher matcher = pattern.matcher(key);
if (matcher.matches()) {
result.add(Integer.parseInt(matcher.group(1)));
}
}
}
return result;
}
public static void add(Composable source, Composable target, double mnoznik) {
BeanWrapper wrapperSource = new BeanWrapperImpl(source);
BeanWrapper wrapperTarget = new BeanWrapperImpl(target);
for (int i = 0; i < wrapperSource.getPropertyDescriptors().length; ++i) {
String propName = wrapperSource.getPropertyDescriptors()[i].getName();
if (wrapperSource.isReadableProperty(propName)) {
Object propValue = wrapperSource.getPropertyValue(propName);
if (propValue != null) {
if (propValue instanceof Composable) {
if ((Composable) wrapperTarget.getPropertyValue(propName) == null)
System.out.println(propName);
add(
(Composable) propValue,
(Composable) wrapperTarget.getPropertyValue(propName),
mnoznik);
} else if (propValue instanceof Double) {
if (wrapperTarget.getPropertyValue(propName) == null)
wrapperTarget.setPropertyValue(propName, 0.0);
wrapperTarget.setPropertyValue(
propName,
((Double) wrapperTarget.getPropertyValue(propName)) + mnoznik * (Double) propValue);
}
}
}
}
}
public static double getMass(Composable source, Composed target) {
double wynik = 0;
BeanWrapper wrapper = new BeanWrapperImpl(source);
for (Substance substance : target) {
String propName =
CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, substance.getSubstanceName());
if (wrapper.isReadableProperty(propName)) {
Object propValue = wrapper.getPropertyValue(propName);
if (propValue != null) {
if (propValue instanceof Composable) {
wynik += Compositions.getMass((Composable) propValue, (Composed) substance);
} else if (propValue instanceof Double) {
wynik += (Double) propValue;
}
}
}
}
return wynik;
}
@Override
public Object getActionParameter(String param) {
if (beanWrapper.isReadableProperty(param)) {
return beanWrapper.getPropertyValue(param);
}
return null;
}
/**
* Get the value of the named property, with support for static properties in both Java and Groovy
* classes (which as of Groovy JSR 1.0 RC 01 only have getters in the metaClass)
*
* @param name
* @param type
* @return The property value or null
*/
public Object getPropertyValue(String name, Class type) {
// Handle standard java beans normal or static properties
BeanWrapper ref = getReference();
Object value = null;
if (ref.isReadableProperty(name)) {
value = ref.getPropertyValue(name);
} else {
// Groovy workaround
Object inst = ref.getWrappedInstance();
if (inst instanceof GroovyObject) {
final Map properties = DefaultGroovyMethods.getProperties(inst);
if (properties.containsKey(name)) {
value = properties.get(name);
}
}
}
if (value != null
&& (type.isAssignableFrom(value.getClass())
|| GrailsClassUtils.isMatchBetweenPrimativeAndWrapperTypes(type, value.getClass()))) {
return value;
} else {
return null;
}
}
public void doArtefactConfiguration() {
if (!pluginBean.isReadableProperty(ARTEFACTS)) {
return;
}
List l = (List) plugin.getProperty(ARTEFACTS);
for (Object artefact : l) {
if (artefact instanceof Class) {
Class artefactClass = (Class) artefact;
if (ArtefactHandler.class.isAssignableFrom(artefactClass)) {
try {
application.registerArtefactHandler((ArtefactHandler) artefactClass.newInstance());
} catch (InstantiationException e) {
LOG.error("Cannot instantiate an Artefact Handler:" + e.getMessage(), e);
} catch (IllegalAccessException e) {
LOG.error(
"The constructor of the Artefact Handler is not accessible:" + e.getMessage(), e);
}
} else {
LOG.error("This class is not an ArtefactHandler:" + artefactClass.getName());
}
} else {
if (artefact instanceof ArtefactHandler) {
application.registerArtefactHandler((ArtefactHandler) artefact);
} else {
LOG.error(
"This object is not an ArtefactHandler:"
+ artefact
+ "["
+ artefact.getClass().getName()
+ "]");
}
}
}
}
private void evaluatePluginStatus() {
if (pluginBean.isReadableProperty(STATUS)) {
Object statusObj = GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, STATUS);
if (statusObj != null) {
status = statusObj.toString().toLowerCase();
}
}
}
public Object get(Object key) {
String objectKey = (String) key;
if (beanWrapper.isReadableProperty(objectKey)) {
return beanWrapper.getPropertyValue(objectKey);
} else {
return thisWrapper.getPropertyValue(objectKey);
}
}
@SuppressWarnings("unchecked")
private void evaluatePluginDependencies() {
if (pluginBean.isReadableProperty(DEPENDS_ON)) {
dependencies =
(Map) GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, DEPENDS_ON);
dependencyNames = dependencies.keySet().toArray(new String[dependencies.size()]);
}
}
public void testGenerateController() throws Exception {
GrailsTemplateGenerator generator;
GroovyClassLoader gcl = new GroovyClassLoader(Thread.currentThread().getContextClassLoader());
generator = new DefaultGrailsTemplateGenerator();
Class dc = gcl.parseClass("class Test { \n Long id;\n Long version; }");
GrailsDomainClass domainClass = new DefaultGrailsDomainClass(dc);
File generatedFile = new File("test/grails-app/controllers/TestController.groovy");
if (generatedFile.exists()) {
generatedFile.delete();
}
StringWriter sw = new StringWriter();
generator.generateController(domainClass, sw);
String text = sw.toString();
Class controllerClass = gcl.parseClass(text);
BeanWrapper bean = new BeanWrapperImpl(controllerClass.newInstance());
assertEquals("TestController", controllerClass.getName());
assertTrue(bean.isReadableProperty("list"));
assertTrue(bean.isReadableProperty("update"));
assertTrue(bean.isReadableProperty("create"));
assertTrue(bean.isReadableProperty("list"));
assertTrue(bean.isReadableProperty("show"));
assertTrue(bean.isReadableProperty("edit"));
assertTrue(bean.isReadableProperty("delete"));
Object propertyValue =
GrailsClassUtils.getStaticPropertyValue(controllerClass, "allowedMethods");
assertTrue("allowedMethods property was the wrong type", propertyValue instanceof Map);
Map map = (Map) propertyValue;
assertTrue("allowedMethods did not contain the delete action", map.containsKey("delete"));
assertTrue("allowedMethods did not contain the save action", map.containsKey("save"));
assertTrue("allowedMethods did not contain the update action", map.containsKey("update"));
assertEquals("allowedMethods had incorrect value for delete action", "POST", map.get("delete"));
assertEquals("allowedMethods had incorrect value for save action", "POST", map.get("save"));
assertEquals("allowedMethods had incorrect value for update action", "POST", map.get("update"));
}
@Override
public void doWithWebDescriptor(GPathResult webXml) {
if (pluginBean.isReadableProperty(DO_WITH_WEB_DESCRIPTOR)) {
Closure c = (Closure) plugin.getProperty(DO_WITH_WEB_DESCRIPTOR);
c.setResolveStrategy(Closure.DELEGATE_FIRST);
c.setDelegate(this);
c.call(webXml);
}
}
@SuppressWarnings("unchecked")
private void evaluatePluginInfluencePolicy() {
if (pluginBean.isReadableProperty(INFLUENCES)) {
List influencedList = (List) pluginBean.getPropertyValue(INFLUENCES);
if (influencedList != null) {
influencedPluginNames =
(String[]) influencedList.toArray(new String[influencedList.size()]);
}
}
}
/**
* Read a property value using the property path by invoking a spring {@link BeanWrapper}
*
* @param propertyPath
* @param instance
* @return the property value found on the property path applied to the provided instance.
*/
@Override
public Object doReadPropertyValue(String propertyPath, Object instance) {
BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(instance);
// check if it's safe to write the property.
if (!beanWrapper.isReadableProperty(propertyPath)) {
return null;
}
return beanWrapper.getPropertyValue(propertyPath);
}
private void evaluatePluginVersion() {
if (!pluginBean.isReadableProperty(VERSION)) {
throw new PluginException("Plugin [" + getName() + "] must specify a version!");
}
Object vobj = plugin.getProperty(VERSION);
if (vobj != null) {
version = vobj.toString();
} else {
throw new PluginException(
"Plugin " + this + " must specify a version. eg: def version = 0.1");
}
}
private void evaluatePluginEvictionPolicy() {
if (pluginBean.isReadableProperty(EVICT)) {
List pluginsToEvict =
(List) GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, EVICT);
if (pluginsToEvict != null) {
evictionList = new String[pluginsToEvict.size()];
int index = 0;
for (Object o : pluginsToEvict) {
evictionList[index++] = o != null ? o.toString() : "";
}
}
}
}
@Override
public <T> T getActionParameter(String paramKey, Class<T> t) {
if (t == null) {
return null;
}
if (beanWrapper.isReadableProperty(paramKey)) {
Object val = beanWrapper.getPropertyValue(paramKey);
return (T) val;
}
return null;
}
@Override
public Map<String, Object> getActionParameters() {
Class<?> wrappedClazz = beanWrapper.getWrappedInstance().getClass();
Field[] fields = wrappedClazz.getDeclaredFields();
Map<String, Object> params = new HashMap<String, Object>();
for (Field field : fields) {
String fieldProperty = field.getName();
if (beanWrapper.isReadableProperty(fieldProperty)) {
params.put(fieldProperty, beanWrapper.getPropertyValue(fieldProperty));
}
}
return params;
}
@SuppressWarnings("unchecked")
private void evaluatePluginLoadAfters() {
if (pluginBean.isReadableProperty(PLUGIN_LOAD_AFTER_NAMES)) {
List loadAfterNamesList =
(List)
GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(
plugin, PLUGIN_LOAD_AFTER_NAMES);
if (loadAfterNamesList != null) {
loadAfterNames =
(String[]) loadAfterNamesList.toArray(new String[loadAfterNamesList.size()]);
}
}
if (pluginBean.isReadableProperty(PLUGIN_LOAD_BEFORE_NAMES)) {
List loadBeforeNamesList =
(List)
GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(
plugin, PLUGIN_LOAD_BEFORE_NAMES);
if (loadBeforeNamesList != null) {
loadBeforeNames =
(String[]) loadBeforeNamesList.toArray(new String[loadBeforeNamesList.size()]);
}
}
}
private Object getPropertyValueForPath(Object target, String[] propertyNames) {
BeanWrapper wrapper = new BeanWrapperImpl(target);
Object obj = target;
for (int i = 0; i < propertyNames.length - 1; i++) {
String propertyName = propertyNames[i];
if (wrapper.isReadableProperty(propertyName)) {
obj = wrapper.getPropertyValue(propertyName);
if (obj == null) break;
wrapper = new BeanWrapperImpl(obj);
}
}
return obj;
}
/**
* Looks for a property of the reference instance with a given name and type.
*
* <p>If found its value is returned. We follow the Java bean conventions with augmentation for
* groovy support and static fields/properties. We will therefore match, in this order:
*
* <ol>
* <li>Standard public bean property (with getter or just public field, using normal
* introspection)
* <li>Public static property with getter method
* <li>Public static field
* </ol>
*
* @return property value or null if no property or static field was found
*/
protected Object getPropertyOrStaticPropertyOrFieldValue(String name, Class type) {
BeanWrapper ref = getReference();
Object value = null;
if (ref.isReadableProperty(name)) {
value = ref.getPropertyValue(name);
} else if (GrailsClassUtils.isPublicField(ref.getWrappedInstance(), name)) {
value = GrailsClassUtils.getFieldValue(ref.getWrappedInstance(), name);
} else {
value = GrailsClassUtils.getStaticPropertyValue(clazz, name);
}
if ((value != null) && GrailsClassUtils.isGroovyAssignableFrom(type, value.getClass())) {
return value;
}
return null;
}
public static Object getPropertyOrStaticPropertyOrFieldValue(
BeanWrapper ref, Object obj, String name) {
if (ref.isReadableProperty(name)) {
return ref.getPropertyValue(name);
}
// Look for public fields
if (isPublicField(obj, name)) {
return getFieldValue(obj, name);
}
// Look for statics
Class<?> clazz = obj.getClass();
if (isStaticProperty(clazz, name)) {
return getStaticPropertyValue(clazz, name);
}
return null;
}
public void doWithDynamicMethods(ApplicationContext ctx) {
try {
if (pluginBean.isReadableProperty(DO_WITH_DYNAMIC_METHODS)) {
Closure c = (Closure) plugin.getProperty(DO_WITH_DYNAMIC_METHODS);
if (enableDocumentationGeneration()) {
DocumentationContext.getInstance().setActive(true);
}
c.setDelegate(this);
c.call(new Object[] {ctx});
}
} finally {
if (enableDocumentationGeneration()) {
DocumentationContext.getInstance().reset();
}
}
}
public void doWithApplicationContext(ApplicationContext ctx) {
try {
if (pluginBean.isReadableProperty(DO_WITH_APPLICATION_CONTEXT)) {
Closure c = (Closure) plugin.getProperty(DO_WITH_APPLICATION_CONTEXT);
if (enableDocumentationGeneration()) {
DocumentationContext.getInstance().setActive(true);
}
c.setDelegate(this);
c.call(new Object[] {ctx});
}
} finally {
if (enableDocumentationGeneration()) {
DocumentationContext.getInstance().reset();
}
}
}
/**
* 将对象中的属性值置入到fields中。
*
* <p>对于<code>isValidated()</code>为<code>true</code>的group，该方法无效。
*/
public void mapTo(Object object) {
if (isValidated() || object == null) {
return;
}
if (log.isDebugEnabled()) {
log.debug(
"Mapping properties to fields: group=\"{}\", object={}",
getName(),
ObjectUtil.identityToString(object));
}
BeanWrapper bean = new BeanWrapperImpl(object);
getForm().getFormConfig().getPropertyEditorRegistrar().registerCustomEditors(bean);
for (Field field : getFields()) {
String propertyName = field.getFieldConfig().getPropertyName();
if (bean.isReadableProperty(propertyName)) {
Object propertyValue = bean.getPropertyValue(propertyName);
Class<?> propertyType = bean.getPropertyType(propertyName);
PropertyEditor editor = bean.findCustomEditor(propertyType, propertyName);
if (editor == null) {
editor = BeanUtils.findEditorByConvention(propertyType);
}
if (editor == null) {
if (propertyType.isArray()
|| CollectionFactory.isApproximableCollectionType(propertyType)) {
field.setValues((String[]) bean.convertIfNecessary(propertyValue, String[].class));
} else {
field.setValue(bean.convertIfNecessary(propertyValue, String.class));
}
} else {
editor.setValue(propertyValue);
field.setValue(editor.getAsText());
}
} else {
log.debug(
"No readable property \"{}\" found in type {}",
propertyName,
object.getClass().getName());
}
}
}
private void evaluateObservedPlugins() {
if (pluginBean.isReadableProperty(PLUGIN_OBSERVE)) {
Object observeProperty =
GrailsClassUtils.getPropertyOrStaticPropertyOrFieldValue(plugin, PLUGIN_OBSERVE);
if (observeProperty instanceof Collection) {
Collection observeList = (Collection) observeProperty;
observedPlugins = new String[observeList.size()];
int j = 0;
for (Object anObserveList : observeList) {
String pluginName = anObserveList.toString();
observedPlugins[j++] = pluginName;
}
}
}
if (observedPlugins == null) {
observedPlugins = new String[0];
}
}
protected void init(Object entity) {
this.entity = entity;
beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(entity);
PropertyDescriptor[] descriptors = beanWrapper.getPropertyDescriptors();
if (descriptors.length > 1) {
for (PropertyDescriptor descriptor : descriptors) {
if (beanWrapper.isReadableProperty(descriptor.getName())) {
privateFields.add(descriptor.getName());
}
}
}
Field[] fields = BeanFields.get(entity.getClass());
if (fields != null) {
for (Field field : fields) {
publicFeilds.put(field.getName(), field);
}
}
}
public void doWithRuntimeConfiguration(RuntimeSpringConfiguration springConfig) {
if (pluginBean.isReadableProperty(DO_WITH_SPRING)) {
if (LOG.isDebugEnabled()) {
LOG.debug("Plugin " + this + " is participating in Spring configuration...");
}
Closure c = (Closure) plugin.getProperty(DO_WITH_SPRING);
BeanBuilder bb = new BeanBuilder(getParentCtx(), springConfig, application.getClassLoader());
Binding b = new Binding();
b.setVariable("application", application);
b.setVariable("manager", getManager());
b.setVariable("plugin", this);
b.setVariable("parentCtx", getParentCtx());
b.setVariable("resolver", getResolver());
bb.setBinding(b);
c.setDelegate(bb);
bb.invokeMethod("beans", new Object[] {c});
}
}
private static void copyInternal(Composable source, Composed target, BeanWrapper parent) {
// copy(source, target);
if (target instanceof Mixture) {
Mixture mixture = (Mixture) target;
String totalPropName =
CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, mixture.getSubstanceName() + "Total");
if (parent.isReadableProperty(totalPropName)
&& parent.getPropertyType(totalPropName) == Double.class) {
Double total = (Double) parent.getPropertyValue(totalPropName);
if (total != null) {
if (mixture.isComplete()) {
double t = mixture.getAmount();
mixture.setRemains(Math.max(total - t, 0.0));
} else {
mixture.setAmount(total);
}
}
}
}
}
@Override
public void doWithWebDescriptor(final Element webXml) {
if (!pluginBean.isReadableProperty(DO_WITH_WEB_DESCRIPTOR)) {
return;
}
final Closure c = (Closure) plugin.getProperty(DO_WITH_WEB_DESCRIPTOR);
c.setResolveStrategy(Closure.DELEGATE_FIRST);
c.setDelegate(this);
DefaultGroovyMethods.use(
this,
DOMCategory.class,
new Closure<Object>(this) {
private static final long serialVersionUID = 1;
@Override
public Object call(Object... args) {
return c.call(webXml);
}
});
}
public STRUCT toStruct(Object object, Connection conn, String typeName) throws SQLException {
StructDescriptor descriptor = new StructDescriptor(typeName, conn);
ResultSetMetaData rsmd = descriptor.getMetaData();
int columns = rsmd.getColumnCount();
Object[] values = new Object[columns];
for (int i = 1; i <= columns; i++) {
String column = JdbcUtils.lookupColumnName(rsmd, i).toLowerCase();
PropertyDescriptor fieldMeta = (PropertyDescriptor) this.mappedFields.get(column);
if (fieldMeta != null) {
BeanWrapper bw = new BeanWrapperImpl(object);
if (bw.isReadableProperty(fieldMeta.getName())) {
try {
if (logger.isDebugEnabled()) {
logger.debug(
"Mapping column named \""
+ column
+ "\""
+ " to property \""
+ fieldMeta.getName()
+ "\"");
}
values[i - 1] = bw.getPropertyValue(fieldMeta.getName());
} catch (NotReadablePropertyException ex) {
throw new DataRetrievalFailureException(
"Unable to map column " + column + " to property " + fieldMeta.getName(), ex);
}
} else {
logger.warn(
"Unable to access the getter for "
+ fieldMeta.getName()
+ ". Check that "
+ "get"
+ StringUtils.capitalize(fieldMeta.getName())
+ " is declared and has public access.");
}
}
}
STRUCT struct = new STRUCT(descriptor, conn, values);
return struct;
}
