Toolkit - File System Provider

This post if part of a series about the File System Toolkit - a custom content delivery API for SDL Tridion.

This post explains the logic in the FileSystemProvider class that perform the actual CRUD operations on the JSON model files as it interacts with the underlying file system.

The provider handles also the serialization/deserialization between model objects and JSON by making use of the FasterXML Jackson serializer.

The FileSystemProvider is a singleton that implements the following methods:

Method create(TcmUri)

This is one of the trickier methods of the provider because it has to create different stub objects based on the type of the TcmUri passed as parameter. Namely, it will create either a ComponentMetaImpl or a PageMetaImpl object and it will populate its TcmUri property. I chose to implement this method using reflection, because it can provide more flexibility in the future, in case other types are required to be initialized.

public <T extends ItemMeta> T create(TcmUri tcmUri) {
    T result;
    Class<T> aClass = ModelUtils.getClass(tcmUri);
    try {
        result = aClass.newInstance();
        Method setTcmUri = aClass.getMethod("setTcmUri", TcmUri.class);
        setTcmUri.invoke(result, tcmUri);
    } catch (InstantiationException | IllegalAccessException |
            NoSuchMethodException | InvocationTargetException e) {
        throw new ModelException(e);
    }

    return result;
}

Method read(TcmUri)

The method uses the PathMapper to identify the path of a JSON file on the file system, it retrieves it and then it performs a deserialize using the Jackson deserializer. It also identifies the type of the model to be returned by looking at the type inside the TcmUri passed as parameter.

public <T extends ItemMeta> T read(TcmUri tcmUri) {
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file = new File(path);
    if (!file.exists()) {
        return null;
    }

    try {
        Class<T> aClass = ModelUtils.getClass(tcmUri);
        T model = serializer.deserialize(file, aClass);
        return model;
    } catch (SerializationException se) {
        throw new ModelException(se);
    }
}

Method update(T model)

The method uses the PathMapper to identify the path of a JSON file on the file system, and if it doesn't exist, it creates the folder structure up until the model JSON file. It then uses the Jackson serializer to serialize the model passed as parameter and write it to the file system.

public <T extends ItemMeta> T update(T model) {
    TcmUri tcmUri = model.getTcmUri();
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file = new File(path);

    if (!file.exists()) {
        File directory = file.getParentFile();
        if (!directory.exists()) {
            if (!directory.mkdirs()) {
                log.error("Directory {} was not created", directory);
            }
        }
    }

    serializer.serialize(file, model);

    return model;
}

Method delete(TcmUri)

The method uses the PathMapper to identify the JSON model file on the file system and then it deletes it.

This is one of the tricker methods in the provider, because it needs to perform a cleanup once a directory is left empty after a model has been deleted.

public boolean delete(TcmUri tcmUri) {
    String path = pathMapper.getModelAbsolutePath(tcmUri);
    File file = new File(path);

    if (file.exists()) {
        if (file.delete()) {
            if (isCleanup) {
                deleteEmptyFolders(file.getParentFile());
            }
            return true;
        }
    }

    return false;
}