• Home
• org.usergrid
• usergrid-services
• 0.0.26
• source code
• AbstractService.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.usergrid.services.AbstractService Maven / Gradle / Ivy

/*******************************************************************************
 * Copyright 2012 Apigee Corporation
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package org.usergrid.services;

import static org.usergrid.security.shiro.utils.SubjectUtils.getPermissionFromPath;
import static org.usergrid.services.ServiceParameter.filter;
import static org.usergrid.services.ServiceParameter.mergeQueries;
import static org.usergrid.utils.ClassUtils.cast;
import static org.usergrid.utils.InflectionUtils.pluralize;
import static org.usergrid.utils.ListUtils.dequeueCopy;
import static org.usergrid.utils.ListUtils.isEmpty;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import org.apache.commons.lang.NotImplementedException;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.usergrid.persistence.Entity;
import org.usergrid.persistence.EntityManager;
import org.usergrid.persistence.EntityRef;
import org.usergrid.persistence.Query;
import org.usergrid.persistence.Results;
import org.usergrid.persistence.Schema;
import org.usergrid.security.shiro.utils.SubjectUtils;
import org.usergrid.services.ServiceParameter.IdParameter;
import org.usergrid.services.ServiceParameter.NameParameter;
import org.usergrid.services.ServiceParameter.QueryParameter;
import org.usergrid.services.ServiceResults.Type;
import org.usergrid.services.exceptions.ServiceInvocationException;
import org.usergrid.services.exceptions.ServiceResourceNotFoundException;
import org.usergrid.services.exceptions.UnsupportedServiceOperationException;

/**
 * Implementation of Service inferface. Builds a method call fanout from the
 * invoke() method so that overriding specific behvaviors can be done easily.
 * 
 * @author edanuff
 * 
 */
public abstract class AbstractService implements Service {

  private static final Logger logger = LoggerFactory.getLogger(AbstractService.class);

  private ServiceInfo info;

  protected EntityManager em;

  protected ServiceManager sm;

  protected Set privateConnections;
  protected Set declaredConnections;

  protected Set privateCollections;
  protected Set declaredCollections;

  protected Map, List> replaceParameters;

  protected Set serviceCommands;
  protected Set entityDictionaries;
  protected Set metadataTypes;
  protected Set entityCommands;

  protected Map defaultEntityMetadata;

  public AbstractService() {

  }

  public void setServiceManager(ServiceManager sm) {
    this.sm = sm;
    em = sm.getEntityManager();
  }

  public ApplicationContext getApplicationContext() {
    return sm.getApplicationContext();
  }

  public void init(ServiceInfo info) {
    this.info = info;
  }

  public ServiceInfo getServiceInfo() {
    return info;
  }

  @Override
  public String getServiceType() {
    if (info == null) {
      return null;
    }
    return info.getName();
  }

  @Override
  public Class getEntityClass() {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public String getEntityType() {
    if (info == null) {
      return null;
    }
    return info.getItemType();
  }

  @Override
  public boolean isRootService() {
    if (info == null) {
      return false;
    }
    return info.isRootService();
  }

  public boolean isCollectionReversed(ServiceContext context) {
    if (info == null) {
      return false;
    }
    if ("application".equals(context.getOwner().getType())) {
      return Schema.getDefaultSchema().isCollectionReversed("application", pluralize(info.getItemType()));
    }
    return Schema.getDefaultSchema().isCollectionReversed(info.getContainerType(), info.getCollectionName());
  }

  public String getCollectionSort(ServiceContext context) {
    if (info == null) {
      return null;
    }
    if ("application".equals(context.getOwner().getType())) {
      return Schema.getDefaultSchema().getCollectionSort("application", pluralize(info.getItemType()));
    }
    return Schema.getDefaultSchema().getCollectionSort(info.getContainerType(), info.getCollectionName());
  }

  public void makeConnectionPrivate(String connection) {
    if (privateConnections == null) {
      privateConnections = new LinkedHashSet();
    }
    privateConnections.add(connection);
  }

  public void makeConnectionsPrivate(List connections) {
    if (privateConnections == null) {
      privateConnections = new LinkedHashSet();
    }
    privateConnections.addAll(connections);
  }

  public void declareConnection(String connection) {
    if (declaredConnections == null) {
      declaredConnections = new LinkedHashSet();
    }
    declaredConnections.add(connection);
  }

  public void declareConnections(List connections) {
    if (declaredConnections == null) {
      declaredConnections = new LinkedHashSet();
    }
    declaredConnections.addAll(connections);
  }

  public void makeCollectionPrivate(String collection) {
    if (privateCollections == null) {
      privateCollections = new LinkedHashSet();
    }
    privateCollections.add(collection);
  }

  public void makeCollectionsPrivate(List collections) {
    if (privateCollections == null) {
      privateCollections = new LinkedHashSet();
    }
    privateCollections.addAll(collections);
  }

  public void declareVirtualCollection(String collection) {
    if (declaredCollections == null) {
      declaredCollections = new LinkedHashSet();
    }
    declaredCollections.add(collection);
  }

  public void declareVirtualCollections(List collections) {
    if (declaredCollections == null) {
      declaredCollections = new LinkedHashSet();
    }
    declaredCollections.addAll(collections);
  }

  public void addReplaceParameters(List find, List replace) {
    if (replaceParameters == null) {
      replaceParameters = new LinkedHashMap, List>();
    }
    replaceParameters.put(find, replace);
  }

  public void declareServiceCommands(String command) {
    if (serviceCommands == null) {
      serviceCommands = new LinkedHashSet();
    }
    serviceCommands.add(command);
  }

  public void declareServiceCommands(List commands) {
    if (serviceCommands == null) {
      serviceCommands = new LinkedHashSet();
    }
    serviceCommands.addAll(commands);
  }

  public void declareEntityDictionary(String dictionary) {
    if (entityDictionaries == null) {
      entityDictionaries = new LinkedHashSet();
    }
    entityDictionaries.add(dictionary);
  }

  public void declareEntityDictionaries(List dictionaries) {
    if (entityDictionaries == null) {
      entityDictionaries = new LinkedHashSet();
    }
    entityDictionaries.addAll(dictionaries);
  }

  public void declareMetadataType(String type) {
    if (metadataTypes == null) {
      metadataTypes = new LinkedHashSet();
    }
    metadataTypes.add(type);
  }

  public void declareMetadataTypes(List typeList) {
    if (metadataTypes == null) {
      metadataTypes = new LinkedHashSet();
    }
    metadataTypes.addAll(typeList);
  }

  public void declareEntityCommand(String command) {
    if (entityCommands == null) {
      entityCommands = new LinkedHashSet();
    }
    entityCommands.add(command);
  }

  public void declareEntityCommands(List commands) {
    if (entityCommands == null) {
      entityCommands = new LinkedHashSet();
    }
    entityCommands.addAll(commands);
  }

  @Override
  public Entity getEntity(ServiceRequest request, UUID uuid) throws Exception {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public Entity getEntity(ServiceRequest request, String name) throws Exception {
    // TODO Auto-generated method stub
    return null;
  }

  public Entity importEntity(ServiceContext context, Entity entity) throws Exception {
    return importEntity(context.getRequest(), entity);
  }

  @Override
  public Entity importEntity(ServiceRequest request, Entity entity) throws Exception {
    if (entity == null) {
      return null;
    }

    if (!isRootService()) {
      return sm.importEntity(request, entity);
    }

    String path = request.getPath() + "/" + entity.getUuid();
    Map metadata = new LinkedHashMap();
    metadata.put("path", path);

    if (defaultEntityMetadata != null) {
      metadata.putAll(defaultEntityMetadata);
    }

    Set