CELDEV-1006 - refactor AttachmentURLCommand to ResourceUrlService

pom.xml

@@ -79,7 +79,7 @@
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>com.xpn.xwiki.platform.plugins</groupId>
+      <groupId>com.celements</groupId>
       <artifactId>xwiki-plugin-scheduler</artifactId>
       <scope>provided</scope>
     </dependency>

src/main/java/com/celements/filebase/references/FileReference.java

@@ -0,0 +1,202 @@
+package com.celements.filebase.references;
+
+import static com.google.common.base.Preconditions.*;
+
+import java.io.Serializable;
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import javax.ws.rs.core.UriBuilder;
+
+import org.xwiki.model.reference.DocumentReference;
+
+import com.celements.model.util.ModelUtils;
+import com.google.common.base.Strings;
+import com.google.common.base.Suppliers;
+import com.google.errorprone.annotations.Immutable;
+import com.xpn.xwiki.web.Utils;
+
+@Immutable
+public final class FileReference implements Serializable {
+
+  private static final long serialVersionUID = 1L;
+
+  @NotThreadSafe
+  public static final class Builder {
+
+    private static final String ATTACHMENT_LINK_REGEX = "([\\w\\-]*:)?([\\w\\-]*\\.[\\w\\-]*){1};.*";
+    private static final Supplier<Pattern> ATTACHMENT_LINK_PATTERN = Suppliers
+        .memoize(() -> Pattern.compile(ATTACHMENT_LINK_REGEX));
+    private static final String ON_DISK_LINK_REGEX = "^:[/\\w\\-\\.]*";
+    private static final Supplier<Pattern> ON_DISK_LINK_PATTERN = Suppliers
+        .memoize(() -> Pattern.compile(ON_DISK_LINK_REGEX));
+
+    private String name;
+    private FileReferenceType type;
+    private DocumentReference docRef;
+    private String fullPath;
+    private String queryString;
+
+    @NotNull
+    private static String getAttachmentName(@NotEmpty String link) {
+      return link.split(";")[1];
+    }
+
+    @NotNull
+    private static String getPathFileName(@NotEmpty String link) {
+      String[] linkParts = link.split("/");
+      return linkParts[linkParts.length - 1];
+    }
+
+    private static boolean isAttachmentLink(@Nullable String link) {
+      if (link != null) {
+        return ATTACHMENT_LINK_PATTERN.get().matcher(link.trim()).matches();
+      }
+      return false;
+    }
+
+    private static boolean isOnDiskLink(@Nullable String link) {
+      if (link != null) {
+        return ON_DISK_LINK_PATTERN.get().matcher(link.trim()).matches();
+      }
+      return false;
+    }
+
+    @NotNull
+    private static DocumentReference getPageDocRef(@NotNull String link) {
+      return Utils.getComponent(ModelUtils.class).resolveRef(link.split(";")[0],
+          DocumentReference.class);
+    }
+
+    private static FileReferenceType getTypeOfLink(@NotEmpty String link) {
+      if (isOnDiskLink(link)) {
+        return FileReferenceType.ON_DISK;
+      } else if (isAttachmentLink(link)) {
+        return FileReferenceType.ATTACHMENT;
+      }
+      return FileReferenceType.EXTERNAL;
+    }
+
+    public Builder setFileName(@NotNull String fileName) {
+      checkNotNull(fileName);
+      this.name = fileName;
+      return this;
+    }
+
+    public Builder setType(@NotNull FileReferenceType type) {
+      checkNotNull(type);
+      this.type = type;
+      return this;
+    }
+
+    public void setDocRef(@NotNull DocumentReference docRef) {
+      checkNotNull(docRef);
+      this.docRef = docRef;
+    }
+
+    public void setFullPath(@NotNull String fullPath) {
+      checkNotNull(fullPath);
+      this.fullPath = fullPath;
+    }
+
+    public void setQueryString(@NotNull String queryString) {
+      checkNotNull(queryString);
+      this.queryString = queryString;
+    }
+
+    public FileReference build() {
+      return new FileReference(this);
+    }
+
+  }
+
+  private final String name;
+  private final FileReferenceType type;
+  private final DocumentReference docRef;
+  private final String fullPath;
+  private final String queryString;
+
+  public FileReference(Builder builder) {
+    this.name = builder.name;
+    this.type = builder.type;
+    this.fullPath = builder.fullPath;
+    this.docRef = builder.docRef;
+    this.queryString = builder.queryString;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public FileReferenceType getType() {
+    return type;
+  }
+
+  public DocumentReference getDocRef() {
+    return docRef;
+  }
+
+  public String getFullPath() {
+    return fullPath;
+  }
+
+  public String getQueryString() {
+    return queryString;
+  }
+
+  public UriBuilder getUri() {
+    return UriBuilder.fromPath(fullPath).replaceQuery(queryString);
+  }
+
+  public boolean isAttachmentReference() {
+    return type == FileReferenceType.ATTACHMENT;
+  }
+
+  public boolean isOnDiskReference() {
+    return type == FileReferenceType.ON_DISK;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(name, type, docRef, fullPath);
+  }
+
+  @Override
+  public boolean equals(@Nullable Object obj) {
+    return (obj instanceof FileReference)
+        && Objects.equals(((FileReference) obj).name, this.name)
+        && Objects.equals(((FileReference) obj).type, this.type)
+        && Objects.equals(((FileReference) obj).docRef, this.docRef)
+        && Objects.equals(((FileReference) obj).fullPath, this.fullPath);
+  }
+
+  @Override
+  public String toString() {
+    return "FileReference [name=" + name + ", type=" + type + ", docRef=" + docRef + ", fullPath="
+        + fullPath + "]";
+  }
+
+  public static Builder of(@NotEmpty String link) {
+    checkArgument(!Strings.isNullOrEmpty(link), "link may not be empty");
+    final String[] linkParts = link.split("\\?");
+    Builder builder = new Builder();
+    builder.setType(Builder.getTypeOfLink(linkParts[0]));
+    if (builder.type == FileReferenceType.ATTACHMENT) {
+      builder.setFileName(Builder.getAttachmentName(linkParts[0]));
+      builder.setDocRef(Builder.getPageDocRef(linkParts[0]));
+    } else {
+      builder.setFileName(Builder.getPathFileName(linkParts[0]));
+      builder.setFullPath(linkParts[0]);
+    }
+    if (linkParts.length > 1) {
+      builder.setQueryString(linkParts[1]);
+    }
+    return builder;
+  }
+
+}

src/main/java/com/celements/filebase/references/FileReferenceType.java

@@ -0,0 +1,7 @@
+package com.celements.filebase.references;
+
+public enum FileReferenceType {
+
+  ON_DISK, ATTACHMENT, EXTERNAL;
+
+}

src/main/java/com/celements/filebase/uri/FileNotExistException.java

@@ -0,0 +1,32 @@
+package com.celements.filebase.uri;
+
+import javax.validation.constraints.NotNull;
+
+import com.celements.filebase.references.FileReference;
+
+public class FileNotExistException extends Exception {
+
+  private static final long serialVersionUID = 1L;
+
+  private final FileReference fileReference;
+
+  public FileNotExistException(@NotNull FileReference fileRef) {
+    super("Url fileRef [" + fileRef + "] does not exist.");
+    this.fileReference = fileRef;
+  }
+
+  public FileNotExistException(@NotNull String message, @NotNull FileReference fileRef) {
+    super(message);
+    this.fileReference = fileRef;
+  }
+
+  public FileNotExistException(@NotNull String message, @NotNull FileReference fileRef,
+      Exception wrapExp) {
+    super(message, wrapExp);
+    this.fileReference = fileRef;
+  }
+
+  public FileReference getFileReference() {
+    return fileReference;
+  }
+}

src/main/java/com/celements/filebase/uri/FileUriScriptService.java

@@ -0,0 +1,105 @@
+package com.celements.filebase.uri;
+
+import java.util.Optional;
+
+import javax.annotation.Nullable;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import javax.ws.rs.core.UriBuilder;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xwiki.component.annotation.Component;
+import org.xwiki.component.annotation.Requirement;
+import org.xwiki.script.service.ScriptService;
+
+import com.celements.filebase.references.FileReference;
+import com.google.common.base.Strings;
+
+import groovy.lang.Singleton;
+
+@Component(FileUriScriptService.NAME)
+@Singleton
+public class FileUriScriptService implements ScriptService {
+
+  public static final String NAME = "fileUri";
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(FileUriScriptService.class);
+
+  @Requirement
+  private FileUriServiceRole fileUriService;
+
+  @NotNull
+  public FileReference createFileReference(@NotEmpty String link) {
+    return FileReference.of(link).build();
+  }
+
+  @NotNull
+  public UriBuilder createFileUrl(@Nullable String fileRef) {
+    return createFileUrl(fileRef, null);
+  }
+
+  @NotNull
+  public UriBuilder createFileUrl(@Nullable String fileRef, @Nullable String action) {
+    return createFileUrl(fileRef, action, null);
+  }
+
+  @NotNull
+  public UriBuilder createFileUrl(@Nullable String fileRef, @Nullable String action,
+      @Nullable String queryString) {
+    if (!Strings.isNullOrEmpty(fileRef)) {
+      return createFileUrl(createFileReference(fileRef), action, queryString);
+    }
+    return UriBuilder.fromPath("");
+  }
+
+  @NotNull
+  public UriBuilder createFileUrl(@Nullable FileReference fileRef, @Nullable String action,
+      @Nullable String queryString) {
+    if (fileRef != null) {
+      try {
+        return fileUriService.createFileUri(fileRef, Optional.ofNullable(action),
+            Optional.ofNullable(queryString));
+      } catch (FileNotExistException exp) {
+        LOGGER.info("createFileUrl for [{}] with action [{}] an queryString [{}] failed.", fileRef,
+            action, queryString, exp);
+      }
+    }
+    return UriBuilder.fromPath("");
+  }
+
+  @NotNull
+  public UriBuilder getFileURLPrefix() {
+    return fileUriService.getFileUriPrefix(Optional.empty());
+  }
+
+  @NotNull
+  public UriBuilder getFileURLPrefix(@Nullable String action) {
+    return fileUriService.getFileUriPrefix(Optional.ofNullable(action));
+  }
+
+  @NotNull
+  public UriBuilder createAbsoluteFileUri(@Nullable String fileRef, @Nullable String action) {
+    return createAbsoluteFileUri(fileRef, action, null);
+  }
+
+  @NotNull
+  public UriBuilder createAbsoluteFileUri(@Nullable String fileRef, String action,
+      @Nullable String queryString) {
+    if (!Strings.isNullOrEmpty(fileRef)) {
+      return createAbsoluteFileUri(createFileReference(fileRef), action, queryString);
+    }
+    return UriBuilder.fromPath("");
+  }
+
+  @NotNull
+  public UriBuilder createAbsoluteFileUri(@Nullable FileReference fileRef, String action,
+      @Nullable String queryString) {
+    if (fileRef != null) {
+      return fileUriService.createAbsoluteFileUri(fileRef, Optional.ofNullable(action),
+          Optional.ofNullable(queryString));
+    }
+    return UriBuilder.fromPath("");
+  }
+
+}