RepoFile.java

package co.codewizards.cloudstore.local.persistence;

import static co.codewizards.cloudstore.core.oio.OioFileFactory.*;
import static co.codewizards.cloudstore.core.util.Util.*;

import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.UUID;

import javax.jdo.JDOHelper;
import javax.jdo.annotations.Discriminator;
import javax.jdo.annotations.DiscriminatorStrategy;
import javax.jdo.annotations.Index;
import javax.jdo.annotations.Indices;
import javax.jdo.annotations.NullValue;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.Queries;
import javax.jdo.annotations.Query;
import javax.jdo.annotations.Unique;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import co.codewizards.cloudstore.core.oio.File;
import co.codewizards.cloudstore.core.util.AssertUtil;

@PersistenceCapable
@Discriminator(strategy=DiscriminatorStrategy.VALUE_MAP)
@Unique(name="RepoFile_parent_name", members={"parent", "name"})
@Indices({
	@Index(name="RepoFile_parent", members={"parent"}),
	@Index(name="RepoFile_localRevision", members={"localRevision"})
})
@Queries({
	@Query(name="getChildRepoFile_parent_name", value="SELECT UNIQUE WHERE this.parent == :parent && this.name == :name"),
	@Query(name="getChildRepoFiles_parent", value="SELECT WHERE this.parent == :parent"),
	@Query(
			name="getRepoFilesChangedAfter_localRevision_exclLastSyncFromRepositoryId",
			value="SELECT WHERE this.localRevision > :localRevision && (this.lastSyncFromRepositoryId == null || this.lastSyncFromRepositoryId != :lastSyncFromRepositoryId)") // TODO this necessary == null is IMHO a DN bug!
})
public abstract class RepoFile extends Entity implements AutoTrackLocalRevision {
	private static final Logger logger = LoggerFactory.getLogger(RepoFile.class);

	private RepoFile parent;

	@Persistent(nullValue=NullValue.EXCEPTION)
	private String name;

	private long localRevision;

	@Persistent(nullValue = NullValue.EXCEPTION)
	private Date lastModified;

	// TODO 1: The direct partner-repository from which this was synced, should be a real relation to the RemoteRepository,
	// because this is more efficient (not a String, but a long id).
	// TODO 2: We should additionally store (and forward) the origin repositoryId (UUID/String) to use this feature during
	// circular syncs over multiple repos - e.g. repoA ---> repoB ---> repoC ---> repoA (again) - this circle would currently
	// cause https://github.com/cloudstore/cloudstore/issues/25 again (because issue 25 is only solved for direct partners - not indirect).
	// TODO 3: We should switch from UUID to Uid everywhere (most importantly the repositoryId).
	// Careful, though: Uid's String-representation is case-sensitive! Due to Windows, it must thus not be used for file names!
	private String lastSyncFromRepositoryId;

	public RepoFile getParent() {
		return parent;
	}
	public void setParent(final RepoFile parent) {
		if (! equal(this.parent, parent))
			this.parent = parent;
	}

	public String getName() {
		return name;
	}
	public void setName(final String name) {
		if (! equal(this.name, name))
			this.name = name;
	}

	/**
	 * {@inheritDoc}
	 * <p>
	 * Note that this does not include modifications of children (in case this is a directory).
	 * If a child is modified, solely this child's localRevision is updated.
	 */
	@Override
	public long getLocalRevision() {
		return localRevision;
	}
	@Override
	public void setLocalRevision(final long localRevision) {
		if (! equal(this.localRevision, localRevision)) {
			if (logger.isDebugEnabled()) {
				final LocalRepository localRepository = new LocalRepositoryDao().persistenceManager(JDOHelper.getPersistenceManager(this)).getLocalRepositoryOrFail();
				logger.debug("setLocalRevision: localRepositoryId={} path='{}' old={} new={}", localRepository.getRepositoryId(), getPath(), this.localRevision, localRevision);
			}
			this.localRevision = localRevision;
		}
	}

	/**
	 * Gets the path within the repository from the {@link LocalRepository#getRoot() root} (including) to <code>this</code> (including).
	 * <p>
	 * The first element in the list is the {@code root}. The last element is <code>this</code>.
	 * <p>
	 * If this method is called on the {@code root} itself, the result will be a list with one single element (the root itself).
	 * @return the path within the repository from the {@link LocalRepository#getRoot() root} (including) to <code>this</code> (including). Never <code>null</code>.
	 */
	public List<RepoFile> getPathList() {
		final LinkedList<RepoFile> path = new LinkedList<RepoFile>();
		RepoFile rf = this;
		while (rf != null) {
			path.addFirst(rf);
			rf = rf.getParent();
		}
		return Collections.unmodifiableList(path);
	}

	/**
	 * Gets the path from the root to <code>this</code>.
	 * <p>
	 * The path's elements are separated by a slash ("/"). The path starts with a slash (like an absolute path), but
	 * is relative to the repository's local root.
	 * @return the path from the root to <code>this</code>. Never <code>null</code>. The repository's root itself has the path "/".
	 */
	public String getPath() {
		final StringBuilder sb = new StringBuilder();
		for (final RepoFile repoFile : getPathList()) {
			if (sb.length() == 0 || sb.charAt(sb.length() - 1) != '/')
				sb.append('/');

			sb.append(repoFile.getName());
		}
		return sb.toString();
	}

	/**
	 * Gets the {@link File} represented by this {@link RepoFile} inside the given repository's {@code localRoot} directory.
	 * @param localRoot the repository's root directory.
	 * @return the {@link File} represented by this {@link RepoFile} inside the given repository's {@code localRoot} directory.
	 */
	public File getFile(final File localRoot) {
		AssertUtil.assertNotNull(localRoot, "localRoot");
		File result = localRoot;
		for (final RepoFile repoFile : getPathList()) {
			if (repoFile.getParent() == null) // skip the root
				continue;

			result = createFile(result, repoFile.getName());
		}
		return result;
	}

	/**
	 * Gets the timestamp of the file's last modification.
	 * <p>
	 * It reflects the {@link File#lastModified() File.lastModified} property.
	 * @return the timestamp of the file's last modification.
	 */
	public Date getLastModified() {
		return lastModified;
	}
	public void setLastModified(final Date lastModified) {
		if (! equal(this.lastModified, lastModified))
			this.lastModified = lastModified;
	}

	public UUID getLastSyncFromRepositoryId() {
		return lastSyncFromRepositoryId == null ? null : UUID.fromString(lastSyncFromRepositoryId);
	}
	public void setLastSyncFromRepositoryId(final UUID repositoryId) {
		if (! equal(this.getLastSyncFromRepositoryId(), repositoryId))
			this.lastSyncFromRepositoryId = repositoryId == null ? null : repositoryId.toString();
	}
}