import java.util.Map;
import java.util.Optional;
import java.util.Properties;
+import java.util.Set;
import java.util.function.Consumer;
+import java.util.stream.Collectors;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.simantics.databoard.util.Base64;
+import org.simantics.db.Resource;
import org.simantics.fileimport.dropins.FileImportDropins;
-import org.simantics.utils.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Files.write(file, bytes);
ConsumerHolder holder = new ConsumerHolder();
- String result = performFileImport(file, Optional.of(holder));
+ String result = performFileImport(file, Optional.empty(), Optional.of(holder));
if (holder.getThrowable() != null)
throw holder.getThrowable();
return result;
}
-
+
/**
* Method that performs the import of the given file. This method is called when e.g. {@link FileImportDropins} watcher detects {@link java.nio.file.StandardWatchEventKinds.ENTRY_CREATE} operation
*
* @param file Path file to be imported
+ * @param possibleSelection - the selected resource (if exists)
* @param callback Optional callback which can be used to catch Throwables thrown in the import process
*/
- public static String performFileImport(Path file, Optional<Consumer<Throwable>> callback) {
+ public static String performFileImport(Path file, Optional<Resource> possibleSelection, Optional<Consumer<Throwable>> callback) {
if (file.getFileName().toString().equals(DB_FILE)) {
return null;
}
String result = "Import failed";
- Optional<IGenericFileImport> serviceOp = findServiceForFileExtension(file);
- if (serviceOp.isPresent()) {
- IGenericFileImport service = serviceOp.get();
+ IGenericFileImport service = findServiceForFileExtension(file);
+
+ if (service != null) {
try {
- Optional<String> resource = service.perform(file);
+ Optional<String> resource;
+ if (possibleSelection.isPresent() && service.defaultParentResource() == null) {
+ resource = Optional.of(Long.toString(service.perform(possibleSelection.get(), file).get().getResourceId()));
+ }
+ else {
+ resource = service.performWithDefaultParent(file);
+ }
saveResourceForPath(file, resource);
result = resource.get();
} catch (Throwable t) {
}
return result;
}
-
/**
* Remove the entity that matches the file. This method is called when e.g. the {@link FileImportDropins} watcher detects {@link java.nio.file.StandardWatchEventKinds.ENTRY_DELETE} operation
* @param callback Optional callback to catch Throwables thrown during the deletion process
*/
public static void removeResourceForFile(Path file, Optional<Consumer<Throwable>> callback) {
- Optional<IGenericFileImport> serviceOp = findServiceForFileExtension(file);
- serviceOp.ifPresent(service -> {
- try {
- Optional<String> resource = getResourceForPath(file);
- if (!resource.isPresent())
- return;
- service.remove(resource.get());
- removeResourceForPath(file);
- } catch (Throwable t) {
- if (callback.isPresent()) {
- callback.get().accept(t);
- } else {
- t.printStackTrace();
- }
+ try {
+ Optional<String> resource = getResourceForPath(file);
+ if (!resource.isPresent())
+ return;
+ IGenericFileImport service = findServiceForFileExtension(file);
+ if (service == null) {
+ LOGGER.warn("Could not find service for importing file " + file);
+ if (callback.isPresent())
+ callback.get().accept(new Exception("Could not find IGenericFileImport service for file " + file));
}
- });
+ service.remove(resource.get());
+ removeResourceForPath(file);
+ } catch (Throwable t) {
+ if (callback.isPresent()) {
+ callback.get().accept(t);
+ } else {
+ LOGGER.error("Could not remove resource for file " + file.toAbsolutePath(), t);
+ }
+ }
}
public static void removeFileForResource(long id, Optional<Consumer<Throwable>> callback) {
try {
fileOp = findPathForId(id);
} catch (IOException e) {
- e.printStackTrace();
+ LOGGER.error("Could not remove file for resource id " + id, e);
return;
}
if (!fileOp.isPresent())
return;
Path file = fileOp.get();
- Optional<IGenericFileImport> serviceOp = findServiceForFileExtension(file);
- serviceOp.ifPresent(service -> {
+
+ try {
+ Optional<String> resource = getResourceForPath(file);
+ if (!resource.isPresent())
+ return;
+ IGenericFileImport service = findServiceForFileExtension(file);
+ if (service == null) {
+ LOGGER.warn("Could not find service for importing file " + file);
+ if (callback.isPresent())
+ callback.get().accept(new Exception("Could not find IGenericFileImport service for file " + file));
+ }
+ service.remove(resource.get());
+ removeResourceForPath(file);
try {
- Optional<String> resource = getResourceForPath(file);
- if (!resource.isPresent())
- return;
- service.remove(resource.get());
- removeResourceForPath(file);
- try {
- Files.delete(file);
- } catch (IOException e) {
- Files.delete(file);
- }
- } catch (Throwable t) {
- if (callback.isPresent()) {
- callback.get().accept(t);
- } else {
- t.printStackTrace();
- }
+ Files.delete(file);
+ } catch (IOException e) {
+ Files.delete(file);
}
- });
+ } catch (Throwable t) {
+ if (callback.isPresent()) {
+ callback.get().accept(t);
+ } else {
+ LOGGER.error("Could not remove file for resource " + id, t);
+ }
+ }
}
private static Optional<Path> findPathForId(long id) throws IOException {
* Method for finding a File Import service for the given file based on the file extension
*
* @param file Path file for which the import service is looked for
- * @return Optiona IGenerigFileImport service which is able to handle the import of this type of file
+ * @return Optional IGenerigFileImport service which is able to handle the import of this type of file
*/
- public static Optional<IGenericFileImport> findServiceForFileExtension(Path file) {
+ public static IGenericFileImport findServiceForFileExtension(Path file) {
String extension = "";
int i = file.getFileName().toString().lastIndexOf('.');
extension = FOLDER;
}
}
+ return findServiceForExtension(extension);
+ }
+
+ public static List<String> filterSupportedExtensions(String filter) {
+ return getFileImportServices().stream().filter(s -> s.allowedExtensionsWithFilters().keySet().contains(filter)).map(s -> s.allowedExtensionsWithFilters().keySet()).flatMap(Set::stream).collect(Collectors.toList());
+ }
+ public static IGenericFileImport findServiceForExtension(String extension) {
+ List<IGenericFileImport> services = findServicesForExtension(extension);
+ IGenericFileImport service = null;
+ if (services.size() == 1) {
+ service = services.get(0);
+ } else {
+ for (IGenericFileImport servicee : services) {
+ service = servicee;
+ if (isPerfectMatch(servicee.allowedExtensionsWithFilters().keySet(), extension))
+ break;
+ }
+ }
+ return service;
+ }
+
+ public static List<IGenericFileImport> findServicesForExtension(String extension) {
+ List<IGenericFileImport> result = new ArrayList<>();
List<IGenericFileImport> services = getFileImportServices();
for (IGenericFileImport service : services) {
for (Map.Entry<String, String> entry : service.allowedExtensionsWithFilters().entrySet()) {
possibleExtensions = possibleExtensions.substring(1);
if (possibleExtensions.equals(extension) || possibleExtensions.isEmpty()) {
if (extension.equals(FOLDER) && possibleExtensions.equals(FOLDER)) {
- return Optional.of(service);
+ result.add(service);
} else if (!extension.isEmpty() && !extension.equals(FOLDER)){
- return Optional.of(service);
+ result.add(service);
}
}
}
}
- return Optional.empty();
+ return result;
}
/**
}
return map;
} catch (IOException e) {
- e.printStackTrace();
+ LOGGER.error("Could not get current paths and resources!", e);
return Collections.emptyMap();
}
}
props.store(stream, null);
}
} catch (IOException e) {
- e.printStackTrace();
+ LOGGER.error("Could not save resource for path " + file.toAbsolutePath() + " and resource " + resource.get(), e);
}
});
}
return Optional.empty();
return Optional.of(value);
}
+
+ /**
+ * Calls the proper imported without a selection (null possibleSelection)
+ * @param path
+ * @param extension
+ * @return
+ * @throws Exception
+ */
+ public static String importGenericFileWithExtension(String path, String extension) throws Exception {
+ IGenericFileImport service = findServiceForExtension(extension);
+ Optional<String> result = service.performWithDefaultParent(Paths.get(path));
+ return result.get();
+ }
+
+ /**
+ * Calls the proper imported without a selection (null possibleSelection)
+ * @param parent
+ * @param path
+ * @param extension
+ * @return
+ * @throws Exception
+ */
+ public static Resource importGenericFileWithExtensionAndParent(Resource parent, String path, String extension) throws Exception {
+ IGenericFileImport service = findServiceForExtension(extension);
+ Optional<Resource> result = service.perform(parent, Paths.get(path));
+ return result.get();
+ }
+
+ private static boolean isPerfectMatch(Set<String> candidates, String extension) {
+ for (String ext : candidates) {
+ if (ext.startsWith("*"))
+ ext = ext.substring(1);
+ if (ext.equals(extension))
+ return true;
+ }
+ return false;
+ }
}