public void deleteEvent(Event event) { List<User> list = getUsers(); Collection<Activity> activities = event.getActivities(); Set<Activity> tmpActivities = new HashSet<Activity>(); for (Activity activityEntity : activities) { tmpActivities.add(activityEntity); } for (User user : list) { boolean userUpdated = false; if (user.getEvents().contains(event)) { for (Activity activity : tmpActivities) { user.getActivities().remove(activity); event.getActivities().remove(activity); } user.getEvents().remove(event); userUpdated = true; } if (userUpdated) { updateObject(user); } } deleteObject(event); // for (Activity activity : tmpActivities) { // deleteObject(activity); // } }
/* (non-Javadoc) * @see org.grails.orm.hibernate.cfg.GrailsDomainConfiguration#addDomainClass(org.codehaus.groovy.grails.commons.GrailsDomainClass) */ public GrailsDomainConfiguration addDomainClass(GrailsDomainClass domainClass) { if (shouldMapWithGorm(domainClass)) { domainClasses.add(domainClass); } else { addAnnotatedClass(domainClass.getClazz()); } return this; }
/** * internal work for responding to a save or update request. This method will add new bundles data * if it doesn't exist, otherwise updates the data preserving any current value if its been * modified. This approach allows for upgrades to automatically detect and persist new keys, as * well as updating any default values that flow in from an upgrade. * * @param baseName * @param moduleName * @param newBundle * @param loc */ protected void saveOrUpdateInternal( String baseName, String moduleName, Map<String, String> newBundle, String loc) { String keyName = getIndexKeyName(baseName, moduleName, loc); if (indexedList.contains(keyName)) { logger.debug("skip saveOrUpdate() as its already happened once for :" + keyName); return; } Set<Entry<String, String>> entrySet = newBundle.entrySet(); Iterator<Entry<String, String>> entries = entrySet.iterator(); while (entries.hasNext()) { Entry<String, String> entry = entries.next(); String key = entry.getKey(); MessageBundleProperty mbp = new MessageBundleProperty(); mbp.setBaseName(baseName); mbp.setModuleName(moduleName); mbp.setLocale(loc.toString()); mbp.setPropertyName(key); mbp.setDefaultValue(entry.getValue()); MessageBundleProperty existingMbp = getProperty(mbp); if (existingMbp != null) { // don"t update id or value, we don't want to loose that data BeanUtils.copyProperties(mbp, existingMbp, new String[] {"id", "value"}); logger.debug( "updating message bundle data for : " + getIndexKeyName(mbp.getBaseName(), mbp.getModuleName(), mbp.getLocale())); updateMessageBundleProperty(existingMbp); } else { logger.debug( "adding message bundle data for : " + getIndexKeyName(mbp.getBaseName(), mbp.getModuleName(), mbp.getLocale())); updateMessageBundleProperty(mbp); } } indexedList.add(getIndexKeyName(baseName, moduleName, loc)); }
/** * schedule timer task to save/update the bundle data. We are using Timer to offload the work, * otherwise intial loads of tools will appear very slow, this way it happens in the background. * In the original rSmart impl JMS was used, but since the MessageService is in contrib not core * we need another solution to avoid that dependency. Currently we are using a java.util.Timer and * scheduled Timer task to queue up and process the calls to this method. This is a similar * strategy to that used in BaseDigestService. * * @param baseName * @param moduleName * @param newBundle * @param loc */ public void saveOrUpdate( String baseName, String moduleName, ResourceBundle newBundle, Locale loc) { String keyName = getIndexKeyName(baseName, moduleName, loc.toString()); if (indexedList.contains(keyName)) { logger.debug("skip saveOrUpdate() as its already happened once for :" + keyName); return; } if (scheduleSaves) { queueBundle(baseName, moduleName, convertResourceBundleToMap(newBundle), loc); } else { saveOrUpdateInternal( baseName, moduleName, convertResourceBundleToMap(newBundle), loc.toString()); } }
/** 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 configureDomainBinder(binder, 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; }