Hallo Daniel,
ein ganzes Beispiel-Modul habe ich dir auf die Schnelle nicht, da ich ansonsten erst einmal viel Code löschen müsste. 😉
Das Geheimnis der Projektlokalen Konfiguration einer ProjectApp, ist dass die Konfiguration von FS im Verzeichnis "C:\...\[Dein FS Verzeichnis]\data\projects\[Dein projekt]\modules\[Dein Modul bzw. ProjectApp]\" gespeichert wird.
Ich habe mir eine zwei kleine Util Klassen geschrieben, die es mir ermöglichen auf die Projektkonfiguration zuzugreifen:
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import xxx.Constants;
import de.espirit.common.base.Logging;
import de.espirit.firstspirit.io.FileHandle;
import de.espirit.firstspirit.module.ProjectEnvironment;
public class xxxProjectAppConfiguration {
private final Class<?> LOGGER = this.getClass();
private Properties configurationProperties;
private final String configurationFile = Constants.PROJECTAPP_CONFIGURATION_FILE_NAME;
private ProjectEnvironment projectEnvironment;
private String moduleName;
private String componentName;
public xxxProjectAppConfiguration(String moduleName, String componentName,
ProjectEnvironment projectEnvironment) {
this.moduleName = moduleName;
this.componentName = componentName;
this.projectEnvironment = projectEnvironment;
this.configurationProperties = new Properties();
}
public Properties loadConfigurationFromFile() {
try {
FileHandle fileHandle = obtainConfigurationFileHandle();
if (fileHandle.isFile()) {
configurationProperties.load(fileHandle.load());
Logging.logInfo("ProjectApp configuration was loaded successfully from file '" + configurationFile
+ "'.", LOGGER);
}
} catch (IOException e) {
Logging.logError("IOException while loading configiuration file '" + configurationFile + "'.", e, LOGGER);
}
return configurationProperties;
}
private FileHandle obtainConfigurationFileHandle() throws IOException {
return projectEnvironment.getConfDir().obtain(configurationFile);
}
public boolean storeConfigurationInFile() {
final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try {
configurationProperties.store(outputStream, null);
FileHandle fileHandle = obtainConfigurationFileHandle();
fileHandle.save(new ByteArrayInputStream(outputStream.toByteArray()));
outputStream.flush();
outputStream.close();
Logging.logInfo("ProjectApp configuration was stored successfully into file '" + configurationFile + "'.",
LOGGER);
} catch (IOException e) {
Logging.logError("Excepton while trying to store the configuration file '" + configurationFile + "'.", e,
LOGGER);
}
return true;
}
public void addConfigurationProperty(String key, String value) {
configurationProperties.setProperty(key, value);
}
public String getParameter(String key) {
if (configurationProperties.isEmpty()) {
loadConfigurationFromFile();
}
return configurationProperties.getProperty(key);
}
public Set<String> getParameterNames() {
Set<String> ret = new HashSet<String>();
for (Enumeration<?> names = configurationProperties.propertyNames(); names.hasMoreElements();) {
ret.add(names.nextElement().toString());
}
return ret;
}
}
Diese Klasse verwende ich um in meinem Konfiguration-Panel der ProjectApp die konfiguratiuonswerte zu speichern, bzw. zu laden.
import static xxx.Constants.PROJECTAPP_NAME;
import static de.espirit.firstspirit.manager.ModuleManager.DirType.CONF;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;
import de.espirit.common.io.IoUtil;
import de.espirit.firstspirit.access.project.Project;
import de.espirit.firstspirit.io.FileHandle;
import de.espirit.firstspirit.io.FileSystem;
import de.espirit.firstspirit.manager.ModuleManager;
import de.espirit.firstspirit.module.EnvironmentDescriptor;
import de.espirit.firstspirit.module.descriptor.ComponentDescriptor;
import de.espirit.firstspirit.module.descriptor.ProjectAppDescriptor;
import de.espirit.firstspirit.server.ManagerProvider;
public class ProjectAppConfigurationUtil {
public static Properties getProjectAppConfiguration(Project project, String configurationFileName)
throws IOException {
Properties config = new Properties();
ModuleManager moduleManager = ((ManagerProvider) project.getUserService().getConnection())
.getManager(ModuleManager.class);
Collection<ComponentDescriptor> components = moduleManager.getComponents(ProjectAppDescriptor.class);
ProjectAppDescriptor appDescriptor = loadProjectAppDescriptor(components);
if (appDescriptor != null) {
EnvironmentDescriptor envDescriptor = EnvironmentDescriptor.create(appDescriptor, project.getId());
FileSystem<?> configDir = moduleManager.getFileSystem(envDescriptor, CONF);
config = loadConfig(configDir, configurationFileName);
}
return config;
}
private static Properties loadConfig(FileSystem<?> confDir, String fileName) throws IOException {
Properties properties;
InputStream inputStream;
FileHandle configurationFile = confDir.obtain(fileName);
if (!configurationFile.isFile()) {
throw new FileNotFoundException("Couldn't find '" + fileName + "' in directory '" + confDir.toString()
+ "'!");
}
properties = new Properties();
inputStream = configurationFile.load();
properties.load(inputStream);
IoUtil.safeClose(inputStream);
return properties;
}
private static ProjectAppDescriptor loadProjectAppDescriptor(Collection<ComponentDescriptor> components) {
ProjectAppDescriptor appDescriptor = null;
for (ComponentDescriptor componentDescriptor : components) {
if (componentDescriptor instanceof ProjectAppDescriptor) {
ProjectAppDescriptor descriptor = (ProjectAppDescriptor) componentDescriptor;
if (descriptor.getName().equals(PROJECTAPP_NAME)) {
appDescriptor = descriptor;
break;
}
}
}
return appDescriptor;
}
}
Diese Klasse verwende ich um aus meinem Service (der beim Aufruf eine projektspezifische Konfiguration ziehen soll) auf die Projektkonfiguratio zuzugreifen.
Vielleicht hilft dir das ja schonmal weiter.
Grüße
Sandro
