@Override public void generateAngularGlobalEntity(GrailsDomainClass grailsDomainClass, String destDir) throws IOException { Assert.hasText(destDir, "Argument [destdir] not specified"); /* Get global template list */ File viewsDir = new File(destDir, "web-app/js/app"); if (!viewsDir.exists()) { viewsDir.mkdirs(); } for (String name : getTemplateNamesFromPath("js/entity")) { File viewsEntityDir = new File(viewsDir.getAbsolutePath() + "/" + grailsDomainClass.getPropertyName()); if (!viewsEntityDir.exists()) { viewsEntityDir.mkdirs(); } generateText( grailsDomainClass, name, viewsDir.getAbsolutePath() + "/" + grailsDomainClass.getPropertyName(), "js/entity", "js"); } }
public void testInsertableUpdateableHibernateMapping() throws Exception { GroovyClassLoader cl = new GroovyClassLoader(); GrailsDomainClass domainClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestInsertableUpdateableDomain {\n" + " Long id \n" + " Long version \n" + " String testString1 \n" + " String testString2 \n" + "\n" + " static mapping = {\n" + " testString1 insertable:false, updateable:false \n" + " testString2 updateable:false, insertable:false \n" + " }\n" + "}")); DefaultGrailsDomainConfiguration config = getDomainConfig(cl, new Class[] {domainClass.getClazz()}); PersistentClass persistentClass = config.getClassMapping("TestInsertableUpdateableDomain"); Property property1 = persistentClass.getProperty("testString1"); assertEquals(false, property1.isInsertable()); assertEquals(false, property1.isUpdateable()); Property property2 = persistentClass.getProperty("testString2"); assertEquals(false, property2.isUpdateable()); assertEquals(false, property2.isInsertable()); }
public void testForeignKeyColumnBinding() { GroovyClassLoader cl = new GroovyClassLoader(); GrailsDomainClass oneClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestOneSide {\n" + " Long id \n" + " Long version \n" + " String name \n" + " String description \n" + "}")); GrailsDomainClass domainClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestManySide {\n" + " Long id \n" + " Long version \n" + " String name \n" + " TestOneSide testOneSide \n" + "\n" + " static mapping = {\n" + " columns {\n" + " testOneSide column:'EXPECTED_COLUMN_NAME'" + " }\n" + " }\n" + "}")); DefaultGrailsDomainConfiguration config = getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()}); PersistentClass persistentClass = config.getClassMapping("TestManySide"); Column column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next(); assertEquals("EXPECTED_COLUMN_NAME", column.getName()); }
public void generateView(GrailsDomainClass domainClass, String viewName, Writer out) throws IOException { String templateText = getTemplateTextView( viewName + ".gsp", "/WEB-INF/templates/angular-scaffolding/views/", "views"); if (!StringUtils.hasLength(templateText)) { return; } GrailsDomainClassProperty multiPart = null; for (GrailsDomainClassProperty property : domainClass.getProperties()) { if (property.getType() == Byte[].class || property.getType() == byte[].class) { multiPart = property; break; } } String packageName = StringUtils.hasLength(domainClass.getPackageName()) ? "<%@ page import=\"" + domainClass.getFullName() + "\" %>" : ""; Map<String, Object> binding = createBinding(domainClass); binding.put("packageName", packageName); binding.put("multiPart", multiPart); binding.put("propertyName", getPropertyName(domainClass)); generate(templateText, binding, out); }
public void testDefaultNamingStrategy() { GroovyClassLoader cl = new GroovyClassLoader(); GrailsDomainClass oneClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestOneSide {\n" + " Long id \n" + " Long version \n" + " String fooName \n" + " String barDescriPtion \n" + "}")); GrailsDomainClass domainClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestManySide {\n" + " Long id \n" + " Long version \n" + " TestOneSide testOneSide \n" + "\n" + " static mapping = {\n" + " columns {\n" + " testOneSide column:'EXPECTED_COLUMN_NAME'" + " }\n" + " }\n" + "}")); DefaultGrailsDomainConfiguration config = getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()}); PersistentClass persistentClass = config.getClassMapping("TestOneSide"); assertEquals("test_one_side", persistentClass.getTable().getName()); Column column = (Column) persistentClass.getProperty("id").getColumnIterator().next(); assertEquals("id", column.getName()); column = (Column) persistentClass.getProperty("version").getColumnIterator().next(); assertEquals("version", column.getName()); column = (Column) persistentClass.getProperty("fooName").getColumnIterator().next(); assertEquals("foo_name", column.getName()); column = (Column) persistentClass.getProperty("barDescriPtion").getColumnIterator().next(); assertEquals("bar_descri_ption", column.getName()); persistentClass = config.getClassMapping("TestManySide"); assertEquals("test_many_side", persistentClass.getTable().getName()); column = (Column) persistentClass.getProperty("id").getColumnIterator().next(); assertEquals("id", column.getName()); column = (Column) persistentClass.getProperty("version").getColumnIterator().next(); assertEquals("version", column.getName()); column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next(); assertEquals("EXPECTED_COLUMN_NAME", column.getName()); }
public void testDomainClassBinding() { GroovyClassLoader cl = new GroovyClassLoader(); GrailsDomainClass domainClass = new DefaultGrailsDomainClass( cl.parseClass( "public class BinderTestClass {\n" + " Long id; \n" + " Long version; \n" + "\n" + " String firstName; \n" + " String lastName; \n" + " String comment; \n" + " Integer age;\n" + " boolean active = true" + "\n" + " static constraints = {\n" + " firstName(nullable:true,size:4..15)\n" + " lastName(nullable:false)\n" + " age(nullable:true)\n" + " }\n" + "}")); DefaultGrailsDomainConfiguration config = getDomainConfig(cl, cl.getLoadedClasses()); // Test database mappings PersistentClass persistentClass = config.getClassMapping("BinderTestClass"); assertTrue( "Property [firstName] must be optional in db mapping", persistentClass.getProperty("firstName").isOptional()); assertFalse( "Property [lastName] must be required in db mapping", persistentClass.getProperty("lastName").isOptional()); // Property must be required by default assertFalse( "Property [comment] must be required in db mapping", persistentClass.getProperty("comment").isOptional()); // Test properties assertTrue( "Property [firstName] must be optional", domainClass.getPropertyByName("firstName").isOptional()); assertFalse( "Property [lastName] must be optional", domainClass.getPropertyByName("lastName").isOptional()); assertFalse( "Property [comment] must be required", domainClass.getPropertyByName("comment").isOptional()); assertTrue( "Property [age] must be optional", domainClass.getPropertyByName("age").isOptional()); }
/* (non-Javadoc) * @see org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainConfiguration#addDomainClass(org.codehaus.groovy.grails.commons.GrailsDomainClass) */ public GrailsDomainConfiguration addDomainClass(GrailsDomainClass domainClass) { if (domainClass.getMappingStrategy().equalsIgnoreCase(GrailsDomainClass.GORM)) { domainClasses.add(domainClass); } return this; }
private Class<?> getReferencedTypeForCollection(String name, Object target) { final GrailsApplication grailsApplication = ApplicationHolder.getApplication(); if (grailsApplication != null) { GrailsDomainClass dc = (GrailsDomainClass) grailsApplication.getArtefact( DomainClassArtefactHandler.TYPE, target.getClass().getName()); if (dc != null) { GrailsDomainClassProperty domainProperty = dc.getPropertyByName(name); if (domainProperty != null) { return domainProperty.getReferencedPropertyType(); } } } return null; }
public void generateViews(GrailsDomainClass domainClass, String destDir) throws IOException { Assert.hasText(destDir, "Argument [destdir] not specified"); File viewsDir = new File(destDir, "web-app/partials/" + domainClass.getPropertyName()); if (!viewsDir.exists()) { viewsDir.mkdirs(); } for (String name : getTemplateNamesFromPath("views")) { if (log.isInfoEnabled()) { log.info( "Generating [" + name + "] view for domain class [" + domainClass.getFullName() + "]"); } generateView(domainClass, name, viewsDir.getAbsolutePath()); } }
/** Overrides the default behaviour to including binding of Grails domain classes. */ @Override protected void secondPassCompile() throws MappingException { final Thread currentThread = Thread.currentThread(); final ClassLoader originalContextLoader = currentThread.getContextClassLoader(); if (!configLocked) { if (LOG.isDebugEnabled()) LOG.debug( "[GrailsAnnotationConfiguration] [" + domainClasses.size() + "] Grails domain classes to bind to persistence runtime"); // do Grails class configuration DefaultGrailsDomainConfiguration.configureDomainBinder(grailsApplication, domainClasses); for (GrailsDomainClass domainClass : domainClasses) { final String fullClassName = domainClass.getFullName(); String hibernateConfig = fullClassName.replace('.', '/') + ".hbm.xml"; final ClassLoader loader = originalContextLoader; // don't configure Hibernate mapped classes if (loader.getResource(hibernateConfig) != null) continue; final Mappings mappings = super.createMappings(); if (!GrailsHibernateUtil.usesDatasource(domainClass, dataSourceName)) { continue; } LOG.debug( "[GrailsAnnotationConfiguration] Binding persistent class [" + fullClassName + "]"); Mapping m = binder.getMapping(domainClass); mappings.setAutoImport(m == null || m.getAutoImport()); binder.bindClass(domainClass, mappings, sessionFactoryBeanName); } } try { currentThread.setContextClassLoader(grailsApplication.getClassLoader()); super.secondPassCompile(); createSubclassForeignKeys(); } finally { currentThread.setContextClassLoader(originalContextLoader); } configLocked = true; }
/** * Returns the class type of the searchable property * * @param grailsDomainClass * @param propertyName * @param searchableGrailsDomainClasses * @return */ public static Class getSearchablePropertyAssociatedClass( GrailsDomainClass grailsDomainClass, String propertyName, Collection searchableGrailsDomainClasses) { Assert.notNull(grailsDomainClass, "grailsDomainClass cannot be null"); Assert.notNull(propertyName, "propertyName cannot be null"); return getSearchablePropertyAssociatedClass( grailsDomainClass.getPropertyByName(propertyName), searchableGrailsDomainClasses); }
/** * Is the given class an emebedded property of another domain class? * * @param grailsDomainClass the GrailsDomainClass to check as n embedded property * @param grailsDomainClasses all GrailsDomainClasses * @return true if the given class is an embedded property of another class */ public static boolean isEmbeddedPropertyOfOtherDomainClass( GrailsDomainClass grailsDomainClass, Collection grailsDomainClasses) { for (Iterator iter = grailsDomainClasses.iterator(); iter.hasNext(); ) { GrailsDomainClass other = (GrailsDomainClass) iter.next(); if (grailsDomainClass == other) { continue; } GrailsDomainClassProperty[] domainClassProperties = other.getProperties(); for (int i = 0; i < domainClassProperties.length; i++) { GrailsDomainClass referencedDomainClass = domainClassProperties[i].getReferencedDomainClass(); if (referencedDomainClass != null && referencedDomainClass == grailsDomainClass && domainClassProperties[i].isEmbedded()) { return true; } } } return false; }
/* * Test method for 'org.codehaus.groovy.grails.validation.metaclass.ConstraintsDynamicProperty.get(Object)' */ @SuppressWarnings("rawtypes") public void testGet() throws Exception { GroovyClassLoader gcl = new GroovyClassLoader(); Class<?> groovyClass = gcl.parseClass( "package org.codehaus.groovy.grails.validation\n" + "class Test {\n" + " Long id\n" + // WE NEED this even though GORM 2 doesn't, as we're not a "domain" class within // grails-app " Long version\n" + // WE NEED this even though GORM 2 doesn't, as we're not a "domain" class within // grails-app " String name\n" + "}"); GrailsDomainClass domainClass = new DefaultGrailsDomainClass(groovyClass); Map constraints = domainClass.getConstrainedProperties(); assertNotNull(constraints); assertFalse(constraints.isEmpty()); }
@SuppressWarnings("deprecation") protected Map<String, Object> createBinding(GrailsDomainClass domainClass) { boolean hasHibernate = pluginManager.hasGrailsPlugin("hibernate") || pluginManager.hasGrailsPlugin("hibernate4"); Map<String, Object> binding = new HashMap<String, Object>(); binding.put("pluginManager", pluginManager); binding.put("domainClass", domainClass); binding.put("className", domainClass.getShortName()); binding.put("renderEditor", getRenderEditor()); binding.put("applicationName", grailsApplication.getMetadata().get("app.name")); binding.put( "comparator", hasHibernate ? DomainClassPropertyComparator.class : SimpleDomainClassPropertyComparator.class); return binding; }
@SuppressWarnings("unchecked") private Map resolveConstrainedProperties(Object object, GrailsDomainClass dc) { Map constrainedProperties = null; if (dc != null) { constrainedProperties = dc.getConstrainedProperties(); } else { // is this dead code? , didn't remove in case it's used somewhere MetaClass mc = GroovySystem.getMetaClassRegistry().getMetaClass(object.getClass()); MetaProperty metaProp = mc.getMetaProperty(CONSTRAINTS_PROPERTY); if (metaProp != null) { Object constrainedPropsObj = getMetaPropertyValue(metaProp, object); if (constrainedPropsObj instanceof Map) { constrainedProperties = (Map) constrainedPropsObj; } } } return constrainedProperties; }
public void initialize() { if (domainClass.getIdentifier() != null) { identifier = new GrailsDomainClassPersistentProperty(this, domainClass.getIdentifier()); propertiesByName.put(identifier.getName(), identifier); } if (domainClass.getVersion() != null) { version = new GrailsDomainClassPersistentProperty(this, domainClass.getVersion()); propertiesByName.put(version.getName(), version); } mappingContext.addEntityValidator(this, domainClass.getValidator()); final GrailsDomainClassProperty[] persistentProperties = domainClass.getPersistentProperties(); for (GrailsDomainClassProperty grailsDomainClassProperty : persistentProperties) { PersistentProperty persistentProperty; if (grailsDomainClassProperty.isAssociation()) { if (grailsDomainClassProperty.isEmbedded()) { persistentProperty = createEmbedded(mappingContext, grailsDomainClassProperty); } else if (grailsDomainClassProperty.isOneToMany()) { persistentProperty = createOneToMany(mappingContext, grailsDomainClassProperty); } else if (grailsDomainClassProperty.isHasOne()) { persistentProperty = createOneToOne(mappingContext, grailsDomainClassProperty); } else if (grailsDomainClassProperty.isOneToOne()) { persistentProperty = createOneToOne(mappingContext, grailsDomainClassProperty); } else if (grailsDomainClassProperty.isManyToOne()) { persistentProperty = createManyToOne(mappingContext, grailsDomainClassProperty); } else if (grailsDomainClassProperty.isManyToMany()) { persistentProperty = createManyToMany(mappingContext, grailsDomainClassProperty); } else { persistentProperty = new GrailsDomainClassPersistentProperty(this, grailsDomainClassProperty); } } else if (grailsDomainClassProperty.isBasicCollectionType()) { persistentProperty = createBasicCollection(mappingContext, grailsDomainClassProperty); } else { persistentProperty = new GrailsDomainClassPersistentProperty(this, grailsDomainClassProperty); } propertiesByName.put(grailsDomainClassProperty.getName(), persistentProperty); properties.add(persistentProperty); if (persistentProperty instanceof Association) { associations.add((Association) persistentProperty); } } initialized = true; }
public boolean isInstance(Object obj) { return domainClass.getClazz().isInstance(obj); }
public Class getJavaClass() { return domainClass.getClazz(); }
public String getName() { return domainClass.getFullName(); }
public void testCustomNamingStrategy() throws Exception { // somewhat artificial in that it doesn't test that setting the property // in DataSource.groovy works, but that's handled in DataSourceConfigurationTests GrailsDomainBinder.configureNamingStrategy(CustomNamingStrategy.class); GroovyClassLoader cl = new GroovyClassLoader(); GrailsDomainClass oneClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestOneSide {\n" + " Long id \n" + " Long version \n" + " String fooName \n" + " String barDescriPtion \n" + "}")); GrailsDomainClass domainClass = new DefaultGrailsDomainClass( cl.parseClass( "class TestManySide {\n" + " Long id \n" + " Long version \n" + " TestOneSide testOneSide \n" + "\n" + " static mapping = {\n" + " columns {\n" + " testOneSide column:'EXPECTED_COLUMN_NAME'" + " }\n" + " }\n" + "}")); DefaultGrailsDomainConfiguration config = getDomainConfig(cl, new Class[] {oneClass.getClazz(), domainClass.getClazz()}); PersistentClass persistentClass = config.getClassMapping("TestOneSide"); assertEquals("table_TestOneSide", persistentClass.getTable().getName()); Column column = (Column) persistentClass.getProperty("id").getColumnIterator().next(); assertEquals("col_id", column.getName()); column = (Column) persistentClass.getProperty("version").getColumnIterator().next(); assertEquals("col_version", column.getName()); column = (Column) persistentClass.getProperty("fooName").getColumnIterator().next(); assertEquals("col_fooName", column.getName()); column = (Column) persistentClass.getProperty("barDescriPtion").getColumnIterator().next(); assertEquals("col_barDescriPtion", column.getName()); persistentClass = config.getClassMapping("TestManySide"); assertEquals("table_TestManySide", persistentClass.getTable().getName()); column = (Column) persistentClass.getProperty("id").getColumnIterator().next(); assertEquals("col_id", column.getName()); column = (Column) persistentClass.getProperty("version").getColumnIterator().next(); assertEquals("col_version", column.getName()); column = (Column) persistentClass.getProperty("testOneSide").getColumnIterator().next(); assertEquals("EXPECTED_COLUMN_NAME", column.getName()); }
public boolean hasProperty(String name, Class type) { return domainClass.hasProperty(name); }
public boolean isOwningEntity(PersistentEntity owner) { return domainClass.isOwningClass(owner.getJavaClass()); }
public Object newInstance() { return domainClass.newInstance(); }
protected String getPropertyName(GrailsDomainClass domainClass) { return domainClass.getPropertyName() + domainSuffix; }
public String getDecapitalizedName() { return domainClass.getLogicalPropertyName(); }
private boolean shouldMapWithGorm(GrailsDomainClass domainClass) { return !AnnotationDomainClassArtefactHandler.isJPADomainClass(domainClass.getClazz()) && domainClass.getMappingStrategy().equalsIgnoreCase(GrailsDomainClass.GORM); }
public boolean isRoot() { return domainClass.isRoot(); }
/** * Get the given domain class's searchable property value, if any * * @param grailsDomainClass the Grails domain class * @return the searchable property value, or null */ public static Object getSearchablePropertyValue(GrailsDomainClass grailsDomainClass) { return GrailsClassUtils.getStaticPropertyValue( grailsDomainClass.getClazz(), SEARCHABLE_PROPERTY_NAME); }
public boolean isIdentityName(String propertyName) { return domainClass.getIdentifier().getName().equals(propertyName); }
/** * Is the given GrailsDomainClass a root mapped class in Compass * * @param domainClass the GrailsDomainClass * @param compass Compass * @return true if there is a root mapping for the class in Compass */ public static boolean isRootMappedClass(GrailsDomainClass domainClass, Compass compass) { return ((InternalCompass) compass).getMapping().getRootMappingByClass(domainClass.getClazz()) != null; }