HibCatalogFacade.java example

Explorer
geoserver_trunk-master
package org.geoserver.catalog.hib;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.geoserver.catalog.Catalog;
import org.geoserver.catalog.CatalogFacade;
import org.geoserver.catalog.CatalogInfo;
import org.geoserver.catalog.DataStoreInfo;
import org.geoserver.catalog.FeatureTypeInfo;
import org.geoserver.catalog.LayerGroupInfo;
import org.geoserver.catalog.LayerInfo;
import org.geoserver.catalog.MapInfo;
import org.geoserver.catalog.NamespaceInfo;
import org.geoserver.catalog.ResourceInfo;
import org.geoserver.catalog.StoreInfo;
import org.geoserver.catalog.StyleInfo;
import org.geoserver.catalog.WorkspaceInfo;
import org.geoserver.catalog.impl.DataStoreInfoImpl;

import org.geoserver.catalog.impl.LayerInfoImpl;
import org.geoserver.catalog.impl.NamespaceInfoImpl;
import org.geoserver.catalog.impl.StyleInfoImpl;
import org.geoserver.catalog.impl.WorkspaceInfoImpl;
import org.geoserver.hibernate.AbstractHibFacade;
import org.hibernate.FetchMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.hibernate.proxy.HibernateProxy;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

public class HibCatalogFacade extends AbstractHibFacade implements CatalogFacade {

    /**
     * the catalog
     */
    Catalog catalog;
    
    public Catalog getCatalog() {
        return catalog;
    }
    
    public void setCatalog(Catalog catalog) {
        this.catalog = catalog;
    }
    
    //
    // workspaces
    //
    
    public WorkspaceInfo add(WorkspaceInfo workspace) {
        return persist(workspace);
    }
    
    public void save(WorkspaceInfo workspace) {
        merge(workspace);
    }
    
    public void remove(WorkspaceInfo workspace) {
        delete(workspace);
    }
    
    public WorkspaceInfo detach(WorkspaceInfo workspace) {
        return workspace;
    }
    
    public WorkspaceInfo getWorkspace(String id) {
        return (WorkspaceInfo) first(
            query("from ", WorkspaceInfo.class, " where id = ", param(id)));
    }
    
    public WorkspaceInfo getWorkspaceByName(String name) {
        return (WorkspaceInfo) first(
            query("from ", WorkspaceInfo.class, " where name = ", param(name)));
    }
    
    public List<WorkspaceInfo> getWorkspaces() {
        return (List<WorkspaceInfo>) list(WorkspaceInfo.class);
    }
    
    public WorkspaceInfo getDefaultWorkspace() {
        Query query = 
            query("from ", WorkspaceInfoImpl.class, " where default = ", param(Boolean.TRUE));
        return (WorkspaceInfoImpl) first(query);
    }

    public void setDefaultWorkspace(WorkspaceInfo workspace) {
        //TODO: remove the cast to WorkspaceInfoImpl
        WorkspaceInfo old = getDefaultWorkspace();

        if (old != null) {
            ((WorkspaceInfoImpl)old).setDefault(false);
            save(old);
        }
        
        if (workspace != null) {
            workspace = resolve(workspace);
            ((WorkspaceInfoImpl)workspace).setDefault(true);
            save(workspace);
        }
        
        //fire change event
        catalog.fireModified(catalog, 
            Arrays.asList("defaultWorkspace"), Arrays.asList(old), Arrays.asList(workspace));
    }
    
    //
    // namespaces
    //
    public NamespaceInfo add(NamespaceInfo namespace) {
        return persist(namespace);
    }
    
    public void save(NamespaceInfo namespace) {
        merge(namespace);
    }

    public void remove(NamespaceInfo namespace) {
        delete(namespace);
    }
    
    public NamespaceInfo detach(NamespaceInfo namespace) {
        return namespace;
    }
    
    public NamespaceInfo getNamespace(String id) {
        Query query = query("from ", NamespaceInfo.class, " where id = ", param(id));
        return (NamespaceInfo) first(query);
    }

    public NamespaceInfo getNamespaceByPrefix(String prefix) {
        Query query = query("from ", NamespaceInfo.class, " where prefix = ", param(prefix));
        return (NamespaceInfo) first(query);
    }

    public NamespaceInfo getNamespaceByURI(String uri) {
        Query query = query("from ", NamespaceInfo.class, " where URI = ", param(uri));
        return (NamespaceInfo) first(query);
    }

    public List<NamespaceInfo> getNamespaces() {
        return list(NamespaceInfo.class);
    }
    
    public NamespaceInfo getDefaultNamespace() {
        Query query = query("from ", NamespaceInfo.class, " where default = ", param(Boolean.TRUE));
        return (NamespaceInfo) first(query);
    }
    
    public void setDefaultNamespace(NamespaceInfo namespace) {
        //TODO: remove the cast to NamespaceInfoImpl
        NamespaceInfo old = getDefaultNamespace();

        if (old != null) {
            ((NamespaceInfoImpl)old).setDefault(false);
            save(old);
        }
        
        if (namespace != null) {
            namespace = resolve(namespace);
            ((NamespaceInfoImpl)namespace).setDefault(true);
            save(namespace);
        }
        
        //fire change event
        catalog.fireModified(catalog, 
            Arrays.asList("defaultNamespace"), Arrays.asList(old), Arrays.asList(namespace));
    }
    
    
    //
    // stores
    //
    public StoreInfo add(StoreInfo store) {
        return persist(store);
    }
    
    public void save(StoreInfo store) {
        merge(store);
    }

    public void remove(StoreInfo store) {
        delete(store);
    }
    
    public <T extends StoreInfo> T detach(T store) {
        return store;
    }
    
    public <T extends StoreInfo> T getStore(String id, Class<T> clazz) {
        return (T) first(query("from ", clazz, " where id = ", param(id)));
    }

    public <T extends StoreInfo> T getStoreByName(WorkspaceInfo workspace, String name,
            Class<T> clazz) {
        Query query = null;
        if (workspace == CatalogFacade.ANY_WORKSPACE) {
            query = query("from ", clazz, " where name = ", param(name));
        }
        else {
            query = query("from ", clazz, " where name = ", param(name), " and workspace = ", param(workspace));
        }
        return (T) first(query);
    }

    public <T extends StoreInfo> List<T> getStores(Class<T> clazz) {
        return list(clazz);
    }

    public <T extends StoreInfo> List<T> getStoresByWorkspace(WorkspaceInfo workspace,
            Class<T> clazz) {
        return Collections.unmodifiableList(
            query("from ", clazz, " where workspace = ", param(workspace)).list());
    }

    public DataStoreInfo getDefaultDataStore(WorkspaceInfo workspace) {
        Query query = 
            query("from ", DataStoreInfoImpl.class, " where workspace = ", param(workspace), 
                 " and default = ", param(Boolean.TRUE));
        return (DataStoreInfo) first(query);
    }

    public void setDefaultDataStore(WorkspaceInfo workspace, DataStoreInfo store) {
        //TODO: remove the cast to DataStoreInfoImpl
        DataStoreInfo old = getDefaultDataStore(workspace);

        if (old != null) {
            ((DataStoreInfoImpl)old).setDefault(false);
            save(old);
        }
        
        if (store != null) {
            ((DataStoreInfoImpl)store).setDefault(true);
            save(store);
        }
        
        //fire change event
        catalog.fireModified(catalog, 
            Arrays.asList("defaultDataStore"), Arrays.asList(old), Arrays.asList(store));
    }

    
    //
    // resources
    //
    public ResourceInfo add(ResourceInfo resource) {
        return persist(resource);
    }
    
    public void save(ResourceInfo resource) {
        merge(resource);
    }
    
    public void remove(ResourceInfo resource) {
        delete(resource);
    }
    
    public <T extends ResourceInfo> T detach(T resource) {
        return resource;
    }
    
    public <T extends ResourceInfo> T getResource(String id, Class<T> clazz) {
        return (T) first(query("from ", clazz, " where id = ", param(id)));
    }

    public <T extends ResourceInfo> T getResourceByName(NamespaceInfo namespace, String name,
            Class<T> clazz) {
        Query query = null;
        if (namespace == CatalogFacade.ANY_NAMESPACE) {
            query = query("from ", clazz, " where name = ", param(name));
        }
        else {
            query = query("from ", clazz, " where name = ", param(name), 
                " and namespace.prefix = ", param(namespace.getPrefix()));
        }
        
        return (T) first(query);
    }

    public <T extends ResourceInfo> T getResourceByStore(StoreInfo store, String name,
            Class<T> clazz) {
        Query query = query("from ", clazz, " r where name = ", param(name),
            " and r.store = ", param(store));
        return (T) first(query);
    }

    public <T extends ResourceInfo> List<T> getResources(Class<T> clazz) {
        return (List<T>) list(clazz);
    }

    public <T extends ResourceInfo> List<T> getResourcesByNamespace(NamespaceInfo namespace, Class<T> clazz) {
        Query query = query("select r from ", clazz, " r, ", NamespaceInfo.class, " n",
                " where r.namespace = n and n.prefix = ", param(namespace.getPrefix()));
        return query.list();
    }

    public <T extends ResourceInfo> List<T> getResourcesByStore(StoreInfo store, Class<T> clazz) {
        Query query = query("from ", clazz, " r where r.store = ", param(store));
        return query.list();
    }
    
    //
    // styles
    //
    public StyleInfo add(StyleInfo style) {
        return persist(style);
    }
    
    public void save(StyleInfo style) {
        merge(style);
    }

    public void remove(StyleInfo style) {
        delete(style);
    }
    
    public StyleInfo detach(StyleInfo style) {
        return style;
    }
   
    public StyleInfo getStyle(String id) {
        Query query = query("from ", StyleInfo.class, " where id = ", param(id));
        return (StyleInfo) first(query);
    }

    public StyleInfo getStyleByName(String name) {
        Query query = query("from ", StyleInfo.class, " where name = ", param(name));
        return (StyleInfo) first(query);
    }

    public List<StyleInfo> getStyles() {
        return (List<StyleInfo>) list(StyleInfo.class);
    }
    
    //
    // layers
    //
    public LayerInfo add(LayerInfo layer) {
        
        // FIXME we are replacing some referenced object here because hib would recognized original
        // ones as unattached.
        if (layer.getResource().getId() != null) {
            Query query = query("from ", layer.getResource().getClass(), " where id = ",
                    param(layer.getResource().getId()));
            layer.setResource((ResourceInfo) first(query));
        }

        // FIXME we are replacing some referenced object here because hib would recognized original
        // ones as unattached.
        if (layer.getDefaultStyle() != null) {
            Query query = query("from ", StyleInfo.class, " where id = ", 
                param(layer.getDefaultStyle().getId()));
            layer.setDefaultStyle((StyleInfo) first(query));
        }

        
        return persist(layer);
    }
    
    public void save(LayerInfo layer) {
        merge(layer);
    }
    
    public void remove(LayerInfo layer) {
        delete(layer);
    }
    
    public LayerInfo detach(LayerInfo layer) {
        Session s = sessionFactory.getCurrentSession();
        layer = (LayerInfo) s.createCriteria(LayerInfo.class)
            .setFetchMode("styles", FetchMode.JOIN)
            .setFetchMode("defaultStyle", FetchMode.JOIN)
            .setFetchMode("attribution", FetchMode.JOIN)
            .add(Restrictions.idEq(layer.getId())).uniqueResult();
        
        return layer;
    }
    
    public LayerInfo getLayer(String id) {
        Query query = query("from ", LayerInfo.class, " where id = ", param(id));
        return (LayerInfo) first(query);
    }

    public LayerInfo getLayerByName(String name) {
        Query query = query("from ", LayerInfo.class, " where resource.name = ", param(name));
        return (LayerInfo) first(query);
    }
    
    public List<LayerInfo> getLayers(ResourceInfo resource) {
        Query query = 
            query("from ", LayerInfo.class, " where resource.id = ", param(resource.getId()));
        return (List<LayerInfo>) query.list();
    }

    public List<LayerInfo> getLayers(StyleInfo style) {
        Query query = query("from ", LayerInfo.class, " where defaultStyle.id = ", param(style.getId()));
          
        //TODO: we need to check layer.styles as well, nto sure how to do this with hql...
        //  "or style in elements(layer.styles)", 
        //   " and style.id = ", param(style.getId()));
        return (List<LayerInfo>) query.list();
    }

    public List<LayerInfo> getLayers() {
        return list(LayerInfo.class);
    }
    
    //
    // layer groups
    //
    public LayerGroupInfo add(LayerGroupInfo layerGroup) {
        return persist(layerGroup);
    }

    public void save(LayerGroupInfo layerGroup) {
        merge(layerGroup);
    }
    
    public void remove(LayerGroupInfo layerGroup) {
        delete(layerGroup);
    }
    
    public LayerGroupInfo detach(LayerGroupInfo layerGroup) {
        return layerGroup;
    }
    
    public LayerGroupInfo getLayerGroup(String id) {
        Query query = query("from ", LayerGroupInfo.class, " where id = ", param(id));
        return (LayerGroupInfo) first(query);
    }

    public LayerGroupInfo getLayerGroupByName(String name) {
        Query query = query("from ", LayerGroupInfo.class, " where name = ", param(name));
        return (LayerGroupInfo) first(query);
    }

    public List<LayerGroupInfo> getLayerGroups() {
        return list(LayerGroupInfo.class);
    }
    
    //
    // maps
    //
    public MapInfo add(MapInfo map) {
        return null;
    }
    
    public void save(MapInfo map) {
    }

    public void remove(MapInfo map) {
    }

    public MapInfo detach(MapInfo map) {
        return map;
    }
    
    public MapInfo getMap(String id) {
        return null;
    }

    public MapInfo getMapByName(String name) {
        return null;
    }

    public List<MapInfo> getMaps() {
        return null;
    }

    //
    // Utilities
    //
    WorkspaceInfo resolve(WorkspaceInfo ws) {
        if (ws.getId() == null) {
            WorkspaceInfo resolved = getWorkspaceByName(ws.getName());
            if (resolved != null) {
                return resolved;
            }
        }
        return ws;
    }
    
    NamespaceInfo resolve(NamespaceInfo ns) {
        if (ns.getId() == null) {
            NamespaceInfo resolved = getNamespaceByPrefix(ns.getPrefix());
            if (resolved != null) {
                return resolved;
            }
        }
        
        return ns;
    }
    
    public void dispose() {
    }

    public void resolve() {
    }

    public void syncTo(CatalogFacade other) {
        throw new UnsupportedOperationException();
    }
    
}