* @version $Revision:$
*/
-public class AccountClient extends BaseServiceClient {
+public class AccountClient extends AbstractServiceClientImpl {
/**
*
private AccountProxy accountProxy;
/* (non-Javadoc)
- * @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
+ * @see org.collectionspace.services.client.AbstractServiceClientImpl#getServicePathComponent()
*/
public String getServicePathComponent() {
return "accounts";
import org.collectionspace.services.account.AccountsCommon;
import org.collectionspace.services.account.AccountsCommonList;
import org.collectionspace.services.account.Status;
-import org.collectionspace.services.client.test.AbstractServiceTest;
+import org.collectionspace.services.client.test.AbstractServiceTestImpl;
import org.collectionspace.services.client.test.ServiceRequestType;
import org.jboss.resteasy.client.ClientResponse;
* $LastChangedRevision: 917 $
* $LastChangedDate: 2009-11-06 12:20:28 -0800 (Fri, 06 Nov 2009) $
*/
-public class AccountServiceTest extends AbstractServiceTest {
+public class AccountServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(AccountServiceTest.class);
private String resource2Id = null;
private String resource3Id = null;
/*
- * This method is called only by the parent class, AbstractServiceTest
+ * This method is called only by the parent class, AbstractServiceTestImpl
*/
@Override
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createWithoutTenant(String testName) throws Exception {
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createWithoutUser(String testName) throws Exception {
//to not cause uniqueness violation for account, createList is removed
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
}
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void searchScreenName(String testName) throws Exception {
}
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void searchUserId(String testName) throws Exception {
}
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void searchEmail(String testName) throws Exception {
}
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void searchScreenNameEmail(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read", "readList", "readNonExistent"})
public void update(String testName) throws Exception {
"Data in updated object did not match submitted data.");
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"update"})
public void updatePassword(String testName) throws Exception {
// "Data in updated object did not match submitted data.");
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"update"})
public void updatePasswordWithoutUser(String testName) throws Exception {
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"updatePasswordWithoutUser"})
public void deactivate(String testName) throws Exception {
}
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"deactivate", "readNonExistent", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"deactivate", "readNonExistent", "testSubmitRequest"})
public void updateWrongUser(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"testSubmitRequest", "updateWrongUser"})
public void delete(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"testSubmitRequest", "updateWrongUser"})
public void deleteList(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriInfo;
import org.collectionspace.services.account.storage.AccountStorageClient;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.context.RemoteServiceContextImpl;
import org.collectionspace.services.common.context.ServiceContext;
import org.collectionspace.services.common.document.BadRequestException;
@Consumes("application/xml")
@Produces("application/xml")
public class AccountResource
- extends AbstractCollectionSpaceResource {
+ extends AbstractCollectionSpaceResourceImpl {
final private String serviceName = "accounts";
final Logger logger = LoggerFactory.getLogger(AccountResource.class);
import org.collectionspace.services.account.AccountsCommonList;
import org.collectionspace.services.account.AccountsCommonList.AccountListItem;
import org.collectionspace.services.account.Status;
-import org.collectionspace.services.common.document.AbstractDocumentHandler;
+import org.collectionspace.services.common.document.AbstractDocumentHandlerImpl;
import org.collectionspace.services.common.document.BadRequestException;
import org.collectionspace.services.common.document.DocumentFilter;
import org.collectionspace.services.common.document.DocumentWrapper;
* @author
*/
public class AccountDocumentHandler
- extends AbstractDocumentHandler<AccountsCommon, AccountsCommonList, AccountsCommon, List> {
+ extends AbstractDocumentHandler
Impl<AccountsCommon, AccountsCommonList, AccountsCommon, List> {
private final Logger logger = LoggerFactory.getLogger(AccountDocumentHandler.class);
private AccountsCommon account;
import org.collectionspace.services.common.document.DocumentWrapper;
import org.collectionspace.services.common.document.DocumentWrapperImpl;
import org.collectionspace.services.common.security.SecurityUtils;
-import org.collectionspace.services.common.storage.jpa.JpaStorageClient;
+import org.collectionspace.services.common.storage.jpa.JpaStorageClientImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* state in persistent storage
* @author
*/
-public class AccountStorageClient extends JpaStorageClient {
+public class AccountStorageClient extends JpaStorageClientImpl {
private final Logger logger = LoggerFactory.getLogger(AccountStorageClient.class);
* @version $Revision:$
*/
-public class AcquisitionClient extends BaseServiceClient {
+public class AcquisitionClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision: 621 $
* $LastChangedDate: 2009-09-02 16:49:01 -0700 (Wed, 02 Sep 2009) $
*/
-public class AcquisitionServiceTest extends AbstractServiceTest {
+public class AcquisitionServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(AcquisitionServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for(int i = 0; i < 3; i++){
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
*/
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "read", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.context.MultipartServiceContext;
import org.collectionspace.services.common.context.MultipartServiceContextFactory;
import org.collectionspace.services.common.context.ServiceContext;
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
public class AcquisitionResource
- extends AbstractCollectionSpaceResource {
+ extends AbstractCollectionSpaceResourceImpl {
final private String serviceName = "acquisitions";
final Logger logger = LoggerFactory.getLogger(AcquisitionResource.class);
import org.collectionspace.services.acquisition.AcquisitionsCommonList.AcquisitionListItem;
import org.collectionspace.services.common.document.DocumentHandler.Action;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class AcquisitionDocumentModelHandler
- extends RemoteDocumentModelHandler<AcquisitionsCommon, AcquisitionsCommonList> {
+ extends RemoteDocumentModelHandler
Impl<AcquisitionsCommon, AcquisitionsCommonList> {
private final Logger logger = LoggerFactory.getLogger(AcquisitionDocumentModelHandler.class);
/**
/**\r
* BaseServiceClient is an abstract base client of all service clients\r
*/\r
-public abstract class BaseServiceClient implements CollectionSpaceClient {\r
+public abstract class AbstractServiceClientImpl implements CollectionSpaceClient {\r
\r
- protected final Logger logger = LoggerFactory.getLogger(BaseServiceClient.class);\r
+ protected final Logger logger = LoggerFactory.getLogger(AbstractServiceClientImpl.class);\r
private Properties properties = new Properties();\r
private URL url;\r
private HttpClient httpClient;\r
\r
abstract public String getServicePathComponent();\r
\r
- protected BaseServiceClient() {\r
+ protected AbstractServiceClientImpl() {\r
readProperties();\r
setupHttpClient();\r
}\r
* @version $Revision:$
*/
-public class TestServiceClient extends BaseServiceClient {
+public class TestServiceClient extends AbstractServiceClientImpl {
/**
*
* Default constructor for CollectionObjectClient class.
*
* For Javadoc descriptions of this class's methods, see the ServiceTest interface.
*/
-public abstract class AbstractServiceTest implements ServiceTest {
+public abstract class AbstractServiceTestImpl implements ServiceTest {
private final Logger logger =
- LoggerFactory.getLogger(AbstractServiceTest.class);
+ LoggerFactory.getLogger(AbstractServiceTestImpl.class);
// A base-level client, used (only) to obtain the base service URL.
protected static final TestServiceClient serviceClient =
new TestServiceClient();
* @version $Revision:$
*/
-public class CollectionObjectClient extends BaseServiceClient {
+public class CollectionObjectClient extends AbstractServiceClientImpl {
/**
*
* $LastChangedRevision$
* $LastChangedDate$
*/
-public class CollectionObjectServiceTest extends AbstractServiceTest {
+public class CollectionObjectServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(CollectionObjectServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
* @see org.collectionspace.services.client.test.ServiceTest#createList()
*/
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for (int i = 0; i < 3; i++) {
// Placeholders until the three tests below can be uncommented.
// See Issue CSPACE-401.
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void createWithEmptyEntityBody(String testName) throws Exception {
}
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void createWithMalformedXml(String testName) throws Exception {
setupCreate(testName);
}
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void createWithWrongXmlSchema(String testName) throws Exception {
}
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
// Placeholders until the three tests below can be uncommented.
// See Issue CSPACE-401.
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void updateWithEmptyEntityBody(String testName) throws Exception {
}
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void updateWithMalformedXml(String testName) throws Exception {
// Perform setup.
}
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void updateWithWrongXmlSchema(String testName) throws Exception {
}
}
*/
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import org.collectionspace.services.common.query.QueryManager;
import org.collectionspace.services.common.query.IQueryManager;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.context.MultipartServiceContext;
import org.collectionspace.services.common.context.MultipartServiceContextFactory;
import org.collectionspace.services.common.context.ServiceContext;
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
public class CollectionObjectResource
- extends AbstractCollectionSpaceResource {
+ extends AbstractCollectionSpaceResourceImpl {
static final public String serviceName = "collectionobjects";
final Logger logger = LoggerFactory.getLogger(CollectionObjectResource.class);
import org.collectionspace.services.collectionobject.CollectionobjectsCommonList;
import org.collectionspace.services.collectionobject.CollectionobjectsCommonList.CollectionObjectListItem;
import org.collectionspace.services.common.document.DocumentWrapper;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class CollectionObjectDocumentModelHandler
- extends RemoteDocumentModelHandler<CollectionobjectsCommon, CollectionobjectsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<CollectionobjectsCommon, CollectionobjectsCommonList> {
private final Logger logger = LoggerFactory.getLogger(CollectionObjectDocumentModelHandler.class);
/**
<user>Administrator</user>
<password>Administrator</password>
<client-type>java</client-type>
- <client-class>org.collectionspace.services.nuxeo.client.java.RepositoryJavaClient</client-class>
+ <client-class>org.collectionspace.services.nuxeo.client.java.RepositoryJavaClientImpl</client-class>
</repository-client>
import org.collectionspace.services.common.repository.RepositoryClient;\r
import org.collectionspace.services.common.repository.RepositoryClientFactory;\r
import org.collectionspace.services.common.storage.StorageClient;\r
-import org.collectionspace.services.common.storage.jpa.JpaStorageClient;\r
+import org.collectionspace.services.common.storage.jpa.JpaStorageClientImpl;\r
\r
/**\r
* The Class AbstractCollectionSpaceResource.\r
*/\r
-public abstract class AbstractCollectionSpaceResource\r
+public abstract class AbstractCollectionSpaceResourceImpl\r
implements CollectionSpaceResource {\r
\r
// Fields for default client factory and client\r
/**\r
* Instantiates a new abstract collection space resource.\r
*/\r
- public AbstractCollectionSpaceResource() {\r
+ public AbstractCollectionSpaceResourceImpl() {\r
repositoryClientFactory = RepositoryClientFactory.getInstance();\r
}\r
\r
if(storageClient != null) {\r
return storageClient;\r
}\r
- storageClient = new JpaStorageClient();\r
+ storageClient = new JpaStorageClientImpl();\r
return storageClient;\r
}\r
\r
package org.collectionspace.services.common;
import java.util.Hashtable;
-import org.collectionspace.services.common.config.ServicesConfigReader;
-import org.collectionspace.services.common.config.TenantBindingConfigReader;
+import org.collectionspace.services.common.config.ServicesConfigReaderImpl;
+import org.collectionspace.services.common.config.TenantBindingConfigReaderImpl;
import org.collectionspace.services.nuxeo.client.java.NuxeoConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final Logger logger = LoggerFactory.getLogger(ServiceMain.class);
private NuxeoConnector nuxeoConnector;
private String serverRootDir = null;
- private ServicesConfigReader servicesConfigReader;
- private TenantBindingConfigReader tenantBindingConfigReader;
+ private ServicesConfigReaderImpl servicesConfigReader;
+ private TenantBindingConfigReaderImpl tenantBindingConfigReader;
private ServiceMain() {
}
private void readConfig() throws Exception {
//read service config
- servicesConfigReader = new ServicesConfigReader(getServerRootDir());
+ servicesConfigReader = new ServicesConfigReaderImpl(getServerRootDir());
getServicesConfigReader().read();
- tenantBindingConfigReader = new TenantBindingConfigReader(getServerRootDir());
+ tenantBindingConfigReader = new TenantBindingConfigReaderImpl(getServerRootDir());
getTenantBindingConfigReader().read();
}
/**
* @return the servicesConfigReader
*/
- public ServicesConfigReader getServicesConfigReader() {
+ public ServicesConfigReaderImpl getServicesConfigReader() {
return servicesConfigReader;
}
/**
* @return the tenantBindingConfigReader
*/
- public TenantBindingConfigReader getTenantBindingConfigReader() {
+ public TenantBindingConfigReaderImpl getTenantBindingConfigReader() {
return tenantBindingConfigReader;
}
}
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public abstract class AbstractConfigReader<T>
+public abstract class AbstractConfigReaderImpl<T>
implements ConfigReader<T> {
- private final Logger logger = LoggerFactory.getLogger(AbstractConfigReader.class);
+ private final Logger logger = LoggerFactory.getLogger(AbstractConfigReaderImpl.class);
private String serverRootDir;
- AbstractConfigReader(String serverRootDir) {
+ AbstractConfigReaderImpl(String serverRootDir) {
this.serverRootDir = serverRootDir;
}
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public class ServicesConfigReader
- extends AbstractConfigReader<ServiceConfig> {
+public class ServicesConfigReaderImpl
+ extends AbstractConfigReaderImpl<ServiceConfig> {
final private static String CONFIG_FILE_NAME = "service-config.xml";
- final Logger logger = LoggerFactory.getLogger(ServicesConfigReader.class);
+ final Logger logger = LoggerFactory.getLogger(ServicesConfigReaderImpl.class);
private ServiceConfig serviceConfig;
private ClientType clientType;
private String clientClassName;
- public ServicesConfigReader(String serverRootDir) {
+ public ServicesConfigReaderImpl(String serverRootDir) {
super(serverRootDir);
}
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public class TenantBindingConfigReader
- extends AbstractConfigReader<TenantBindingConfig> {
+public class TenantBindingConfigReaderImpl
+ extends AbstractConfigReaderImpl<TenantBindingConfig> {
final private static String CONFIG_FILE_NAME = "tenant-bindings.xml";
- final Logger logger = LoggerFactory.getLogger(TenantBindingConfigReader.class);
+ final Logger logger = LoggerFactory.getLogger(TenantBindingConfigReaderImpl.class);
private TenantBindingConfig tenantBindingConfig;
//tenant name, tenant binding
private Hashtable<String, TenantBindingType> tenantBindings =
//tenant-qualified service, workspace
private Hashtable<String, String> serviceWorkspaces = new Hashtable<String, String>();
- public TenantBindingConfigReader(String serverRootDir) {
+ public TenantBindingConfigReaderImpl(String serverRootDir) {
super(serverRootDir);
}
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
-import org.collectionspace.services.common.config.TenantBindingConfigReader;
+import org.collectionspace.services.common.config.TenantBindingConfigReaderImpl;
import org.collectionspace.services.common.document.DocumentHandler;
import org.collectionspace.services.common.document.ValidatorHandler;
import org.collectionspace.services.common.security.UnauthorizedException;
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public abstract class AbstractServiceContext<IT, OT>
+public abstract class AbstractServiceContextImpl<IT, OT>
implements ServiceContext<IT, OT> {
- final Logger logger = LoggerFactory.getLogger(AbstractServiceContext.class);
+ final Logger logger = LoggerFactory.getLogger(AbstractServiceContextImpl.class);
Map<String, Object> properties = new HashMap<String, Object>();
Map<String, ObjectPartType> objectPartMap = new HashMap<String, ObjectPartType>();
private ServiceBindingType serviceBinding;
private List<ValidatorHandler> valHandlers = null;
private DocumentHandler docHandler = null;
- public AbstractServiceContext(String serviceName) throws UnauthorizedException {
- TenantBindingConfigReader tReader =
+ public AbstractServiceContextImpl(String serviceName) throws UnauthorizedException {
+ TenantBindingConfigReaderImpl tReader =
ServiceMain.getInstance().getTenantBindingConfigReader();
//FIXME retrieveTenantId is not working consistently in non-auth mode
//TODO: get tenant binding from security context
@Override
public String getQualifiedServiceName() {
- return TenantBindingConfigReader.getTenantQualifiedServiceName(getTenantId(), getServiceName());
+ return TenantBindingConfigReaderImpl.getTenantQualifiedServiceName(getTenantId(), getServiceName());
}
@Override
@Override
public String getRepositoryWorkspaceId() {
- TenantBindingConfigReader tbConfigReader = ServiceMain.getInstance().getTenantBindingConfigReader();
+ TenantBindingConfigReaderImpl tbConfigReader = ServiceMain.getInstance().getTenantBindingConfigReader();
return tbConfigReader.getWorkspaceId(getTenantId(), getServiceName());
}
* $LastChangedDate: $
*/
public class RemoteServiceContextImpl<IT, OT>
- extends AbstractServiceContext<IT, OT>
+ extends AbstractServiceContextImpl<IT, OT>
implements RemoteServiceContext<IT, OT> {
final Logger logger = LoggerFactory.getLogger(RemoteServiceContextImpl.class);
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public abstract class AbstractDocumentHandler<T, TL, WT, WTL>
+public abstract class AbstractDocumentHandlerImpl<T, TL, WT, WTL>
implements DocumentHandler<T, TL, WT, WTL> {
- private final Logger logger = LoggerFactory.getLogger(AbstractDocumentHandler.class);
+ private final Logger logger = LoggerFactory.getLogger(AbstractDocumentHandlerImpl.class);
private Map<String, Object> properties = new HashMap<String, Object>();
private DocumentFilter docFilter = new DocumentFilter();
private ServiceContext serviceContext;
- public AbstractDocumentHandler() {
+ public AbstractDocumentHandlerImpl() {
}
@Override
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public abstract class AbstractMultipartDocumentHandler<T, TL, WT, WTL>
- extends AbstractDocumentHandler<T, TL, WT, WTL>
+public abstract class AbstractMultipartDocumentHandlerImpl<T, TL, WT, WTL>
+ extends AbstractDocumentHandlerImpl<T, TL, WT, WTL>
implements MultipartDocumentHandler<T, TL, WT, WTL> {
- private final Logger logger = LoggerFactory.getLogger(AbstractMultipartDocumentHandler.class);
+ private final Logger logger = LoggerFactory.getLogger(AbstractMultipartDocumentHandlerImpl.class);
- public AbstractMultipartDocumentHandler() {
+ public AbstractMultipartDocumentHandlerImpl() {
}
@Override
import org.nuxeo.ecm.core.client.NuxeoClient;\r
\r
import org.collectionspace.services.nuxeo.client.java.NuxeoConnector;\r
-import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClient;\r
+import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClientImpl;\r
import org.collectionspace.services.common.document.DocumentFilter;\r
import org.collectionspace.services.common.query.IQueryManager;\r
\r
public class QueryManagerNuxeoImpl implements IQueryManager {\r
\r
private final Logger logger = LoggerFactory\r
- .getLogger(RepositoryJavaClient.class);\r
+ .getLogger(RepositoryJavaClientImpl.class);\r
\r
//TODO: This is currently just an example fixed query. This should eventually be\r
// removed or replaced with a more generic method.\r
import java.util.Hashtable;
import org.collectionspace.services.common.RepositoryClientConfigType;
import org.collectionspace.services.common.ServiceMain;
-import org.collectionspace.services.common.config.ServicesConfigReader;
+import org.collectionspace.services.common.config.ServicesConfigReaderImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private RepositoryClientFactory() {
try{
- ServicesConfigReader scReader = ServiceMain.getInstance().getServicesConfigReader();
+ ServicesConfigReaderImpl scReader = ServiceMain.getInstance().getServicesConfigReader();
RepositoryClientConfigType repositoryClientConfig = scReader.getConfiguration().getRepositoryClient();
String clientClassName = repositoryClientConfig.getClientClass();
String clientName = repositoryClientConfig.getName();
*
* $LastChangedRevision: $ $LastChangedDate: $
*/
-public class JpaStorageClient implements StorageClient {
+public class JpaStorageClientImpl implements StorageClient {
/** The logger. */
- private final Logger logger = LoggerFactory.getLogger(JpaStorageClient.class);
+ private final Logger logger = LoggerFactory.getLogger(JpaStorageClientImpl.class);
/** The Constant CS_PERSISTENCE_UNIT. */
protected final static String CS_PERSISTENCE_UNIT = "org.collectionspace.services";
/**
* Instantiates a new jpa storage client.
*/
- public JpaStorageClient() {
+ public JpaStorageClientImpl() {
}
/* (non-Javadoc)
import org.nuxeo.ecm.core.client.NuxeoClient;\r
\r
import org.collectionspace.services.nuxeo.client.java.NuxeoConnector;\r
-import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClient;\r
+import org.collectionspace.services.nuxeo.client.java.RepositoryJavaClientImpl;\r
import org.collectionspace.services.common.query.IQueryManager;\r
\r
public class VocabManagerImpl implements IVocabManager {\r
\r
private final Logger logger = LoggerFactory\r
- .getLogger(RepositoryJavaClient.class);\r
+ .getLogger(RepositoryJavaClientImpl.class);\r
\r
public void exampleMethod(String someParam) {\r
}\r
*/
package org.collectionspace.services.nuxeo.client.java;
-import org.collectionspace.services.common.document.AbstractMultipartDocumentHandler;
+import org.collectionspace.services.common.document.AbstractMultipartDocumentHandlerImpl;
import org.collectionspace.services.common.document.DocumentFilter;
import org.collectionspace.services.common.document.DocumentWrapper;
import org.collectionspace.services.nuxeo.client.*;
* $LastChangedDate: $
*/
public abstract class DocumentModelHandler<T, TL>
- extends AbstractMultipartDocumentHandler<T, TL, DocumentModel, DocumentModelList> {
+ extends AbstractMultipartDocumentHandlerImpl<T, TL, DocumentModel, DocumentModelList> {
private final Logger logger = LoggerFactory.getLogger(DocumentModelHandler.class);
private RepositoryInstance repositorySession;
* $LastChangedRevision: $
* $LastChangedDate: $
*/
-public abstract class RemoteDocumentModelHandler<T, TL>
+public abstract class RemoteDocumentModelHandlerImpl<T, TL>
extends DocumentModelHandler<T, TL> {
- private final Logger logger = LoggerFactory.getLogger(RemoteDocumentModelHandler.class);
+ private final Logger logger = LoggerFactory.getLogger(RemoteDocumentModelHandlerImpl.class);
@Override
public void setServiceContext(ServiceContext ctx) {
*
* $LastChangedRevision: $ $LastChangedDate: $
*/
-public class RepositoryJavaClient implements RepositoryClient {
+public class RepositoryJavaClientImpl implements RepositoryClient {
- private final Logger logger = LoggerFactory.getLogger(RepositoryJavaClient.class);
+ private final Logger logger = LoggerFactory.getLogger(RepositoryJavaClientImpl.class);
- public RepositoryJavaClient() {
+ public RepositoryJavaClientImpl() {
}
/**
* $LastChangedDate: $
*/
-public class ContactClient extends BaseServiceClient {
+public class ContactClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision: 917 $
* $LastChangedDate: 2009-11-06 12:20:28 -0800 (Fri, 06 Nov 2009) $
*/
-public class ContactServiceTest extends AbstractServiceTest {
+public class ContactServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(ContactServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for(int i = 0; i < 3; i++){
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
*/
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
import org.collectionspace.services.common.context.MultipartServiceContext;
@Path("/contacts")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class ContactResource extends AbstractCollectionSpaceResource {
+public class ContactResource extends AbstractCollectionSpaceResourceImpl {
private final static String serviceName = "contacts";
final Logger logger = LoggerFactory.getLogger(ContactResource.class);
import org.collectionspace.services.contact.ContactsCommonList;
import org.collectionspace.services.contact.ContactsCommonList.ContactListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class ContactDocumentModelHandler
- extends RemoteDocumentModelHandler<ContactsCommon, ContactsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<ContactsCommon, ContactsCommonList> {
private final Logger logger = LoggerFactory.getLogger(ContactDocumentModelHandler.class);
/**
* @version $Revision:$
*/
-public class DimensionClient extends BaseServiceClient {
+public class DimensionClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision: 917 $
* $LastChangedDate: 2009-11-06 12:20:28 -0800 (Fri, 06 Nov 2009) $
*/
-public class DimensionServiceTest extends AbstractServiceTest {
+public class DimensionServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(DimensionServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for(int i = 0; i < 3; i++){
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
*/
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.dimension.DimensionsCommonList.*;
import org.collectionspace.services.common.ClientType;
@Path("/dimensions")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class DimensionResource extends AbstractCollectionSpaceResource {
+public class DimensionResource extends AbstractCollectionSpaceResourceImpl {
private final static String serviceName = "dimensions";
final Logger logger = LoggerFactory.getLogger(DimensionResource.class);
import org.collectionspace.services.dimension.DimensionsCommonList;
import org.collectionspace.services.dimension.DimensionsCommonList.DimensionListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class DimensionDocumentModelHandler
- extends RemoteDocumentModelHandler<DimensionsCommon, DimensionsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<DimensionsCommon, DimensionsCommonList> {
private final Logger logger = LoggerFactory.getLogger(DimensionDocumentModelHandler.class);
/**
* @version $Revision:$
*/
-public class IntakeClient extends BaseServiceClient {
+public class IntakeClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
- * @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
+ * @see org.collectionspace.services.client.AbstractServiceClientImpl#getServicePathComponent()
*/
public String getServicePathComponent() {
return "intakes";
* $LastChangedRevision$
* $LastChangedDate$
*/
-public class IntakeServiceTest extends AbstractServiceTest {
+public class IntakeServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(IntakeServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for(int i = 0; i < 3; i++){
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
*/
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
@Path("/intakes")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class IntakeResource extends AbstractCollectionSpaceResource {
+public class IntakeResource extends AbstractCollectionSpaceResourceImpl {
private final static String serviceName = "intakes";
final Logger logger = LoggerFactory.getLogger(IntakeResource.class);
import org.collectionspace.services.intake.IntakesCommonList;
import org.collectionspace.services.intake.IntakesCommonList.IntakeListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class IntakeDocumentModelHandler
- extends RemoteDocumentModelHandler<IntakesCommon, IntakesCommonList> {
+ extends RemoteDocumentModelHandlerImpl<IntakesCommon, IntakesCommonList> {
private final Logger logger = LoggerFactory.getLogger(IntakeDocumentModelHandler.class);
/**
* @version $Revision:$
*/
-public class OrgAuthorityClient extends BaseServiceClient {
+public class OrgAuthorityClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
- * @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
+ * @see org.collectionspace.services.client.AbstractServiceClientImpl#getServicePathComponent()
*/
@Override
public String getServicePathComponent() {
* $LastChangedRevision: 753 $
* $LastChangedDate: 2009-09-23 11:03:36 -0700 (Wed, 23 Sep 2009) $
*/
-public class OrgAuthorityServiceTest extends AbstractServiceTest {
+public class OrgAuthorityServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(OrgAuthorityServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createItem(String testName) {
setupCreate(testName);
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "createItem"})
public void createList(String testName) throws Exception {
for (int i = 0; i < 3; i++) {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
}
*/
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "read"})
public void readItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "readNonExistent"})
public void readItemNonExistent(String testName) {
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
"Data in updated object did not match submitted data.");
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "update"})
public void updateItem(String testName) throws Exception {
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"updateItem", "testItemSubmitRequest"})
public void updateNonExistentItem(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "readItemList", "testItemSubmitRequest",
"updateItem"})
public void deleteItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"deleteItem"})
public void deleteNonExistentItem(String testName) {
import javax.ws.rs.core.UriInfo;
import org.collectionspace.services.OrganizationJAXBSchema;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
import org.collectionspace.services.common.context.MultipartServiceContext;
@Path("/orgauthorities")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class OrgAuthorityResource extends AbstractCollectionSpaceResource {
+public class OrgAuthorityResource extends AbstractCollectionSpaceResourceImpl {
private final static String orgAuthorityServiceName = "orgauthorities";
private final static String organizationServiceName = "organizations";
import org.collectionspace.services.organization.OrgauthoritiesCommonList;
import org.collectionspace.services.organization.OrgauthoritiesCommonList.OrgauthorityListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class OrgAuthorityDocumentModelHandler
- extends RemoteDocumentModelHandler<OrgauthoritiesCommon, OrgauthoritiesCommonList> {
+ extends RemoteDocumentModelHandlerImpl<OrgauthoritiesCommon, OrgauthoritiesCommonList> {
private final Logger logger = LoggerFactory.getLogger(OrgAuthorityDocumentModelHandler.class);
/**
import org.collectionspace.services.OrganizationJAXBSchema;
import org.collectionspace.services.common.document.DocumentWrapper;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.collectionspace.services.organization.OrganizationsCommon;
import org.collectionspace.services.organization.OrganizationsCommonList;
* $LastChangedDate: $
*/
public class OrganizationDocumentModelHandler
- extends RemoteDocumentModelHandler<OrganizationsCommon, OrganizationsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<OrganizationsCommon, OrganizationsCommonList> {
private final Logger logger = LoggerFactory.getLogger(OrganizationDocumentModelHandler.class);
/**
* @version $Revision:$
*/
-public class PersonAuthorityClient extends BaseServiceClient {
+public class PersonAuthorityClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision: 753 $
* $LastChangedDate: 2009-09-23 11:03:36 -0700 (Wed, 23 Sep 2009) $
*/
-public class PersonAuthorityServiceTest extends AbstractServiceTest {
+public class PersonAuthorityServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(PersonAuthorityServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createItem(String testName) {
setupCreate(testName);
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "createItem"})
public void createList(String testName) throws Exception {
for (int i = 0; i < 3; i++) {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
}
*/
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "read"})
public void readItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "readNonExistent"})
public void readItemNonExistent(String testName) {
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
"Data in updated object did not match submitted data.");
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "update"})
public void updateItem(String testName) throws Exception {
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"updateItem", "testItemSubmitRequest"})
public void updateNonExistentItem(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "readItemList", "testItemSubmitRequest",
"updateItem"})
public void deleteItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"deleteItem"})
public void deleteNonExistentItem(String testName) {
import javax.ws.rs.core.UriInfo;
import org.collectionspace.services.PersonJAXBSchema;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
import org.collectionspace.services.common.context.MultipartServiceContext;
@Path("/personauthorities")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class PersonAuthorityResource extends AbstractCollectionSpaceResource {
+public class PersonAuthorityResource extends AbstractCollectionSpaceResourceImpl {
private final static String personAuthorityServiceName = "personauthorities";
private final static String personServiceName = "persons";
import org.collectionspace.services.person.PersonauthoritiesCommonList;
import org.collectionspace.services.person.PersonauthoritiesCommonList.PersonauthorityListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class PersonAuthorityDocumentModelHandler
- extends RemoteDocumentModelHandler<PersonauthoritiesCommon, PersonauthoritiesCommonList> {
+ extends RemoteDocumentModelHandler
Impl<PersonauthoritiesCommon, PersonauthoritiesCommonList> {
private final Logger logger = LoggerFactory.getLogger(PersonAuthorityDocumentModelHandler.class);
/**
import org.collectionspace.services.PersonJAXBSchema;
import org.collectionspace.services.common.document.DocumentWrapper;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.collectionspace.services.person.PersonsCommon;
import org.collectionspace.services.person.PersonsCommonList;
*
*/
public class PersonDocumentModelHandler
- extends RemoteDocumentModelHandler<PersonsCommon, PersonsCommonList> {
+ extends RemoteDocumentModelHandler
Impl<PersonsCommon, PersonsCommonList> {
private final Logger logger = LoggerFactory.getLogger(PersonDocumentModelHandler.class);
/**
* @version $Revision:$
*/
-public class RelationClient extends BaseServiceClient implements RelationProxy {
+public class RelationClient extends AbstractServiceClientImpl implements RelationProxy {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision$
* $LastChangedDate$
*/
-public class RelationServiceTest extends AbstractServiceTest {
+public class RelationServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(RelationServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createList(String testName) throws Exception {
for(int i = 0; i < 3; i++){
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
*/
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.context.MultipartServiceContext;
import org.collectionspace.services.common.context.MultipartServiceContextFactory;
import org.collectionspace.services.common.context.ServiceContext;
@Path("/relations")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class NewRelationResource extends AbstractCollectionSpaceResource {
+public class NewRelationResource extends AbstractCollectionSpaceResourceImpl {
/** The Constant serviceName. */
public final static String serviceName = "relations";
import org.collectionspace.services.relation.RelationsCommonList.RelationListItem;
import org.collectionspace.services.common.document.DocumentWrapper;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
import org.slf4j.Logger;
* $LastChangedDate: $
*/
public class RelationDocumentModelHandler
- extends RemoteDocumentModelHandler<RelationsCommon, RelationsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<RelationsCommon, RelationsCommonList> {
private final Logger logger = LoggerFactory.getLogger(RelationDocumentModelHandler.class);
/**
import org.collectionspace.services.collectionobject.CollectionobjectsCommon;
import org.collectionspace.services.client.CollectionObjectClient;
import org.collectionspace.services.client.CollectionSpaceClient;
-import org.collectionspace.services.client.test.AbstractServiceTest;
+import org.collectionspace.services.client.test.AbstractServiceTestImpl;
import org.jboss.resteasy.plugins.providers.multipart.MultipartOutput;
import org.jboss.resteasy.plugins.providers.multipart.OutputPart;
import org.slf4j.Logger;
* $LastChangedRevision: 434 $ $LastChangedDate: 2009-07-28 14:34:15 -0700 (Tue,
* 28 Jul 2009) $
*/
-public class AuthenticationServiceTest extends AbstractServiceTest {
+public class AuthenticationServiceTest extends AbstractServiceTestImpl {
/** The known resource id. */
private String knownResourceId = null;
return null;
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class)
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class)
public void createAccounts(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
// (e.g. CREATE, DELETE), its valid and expected status codes, and
/* (non-Javadoc)
* @see org.collectionspace.services.client.test.AbstractServiceTest#create()
*/
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"createAccounts"})
@Override
public void create(String testName) {
* @see org.collectionspace.services.client.test.AbstractServiceTest#delete()
*/
@Override
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void delete(String testName) {
setupDelete(testName);
Response.Status.OK.getStatusCode(), "expected " + Response.Status.OK.getStatusCode());
}
- @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTest.class,
+ @Test(dataProvider = "testName", dataProviderClass = AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteAccounts(String testName) throws Exception {
* @version $Revision:$
*/
-public class VocabularyClient extends BaseServiceClient {
+public class VocabularyClient extends AbstractServiceClientImpl {
/* (non-Javadoc)
* @see org.collectionspace.services.client.BaseServiceClient#getServicePathComponent()
* $LastChangedRevision: 753 $
* $LastChangedDate: 2009-09-23 11:03:36 -0700 (Wed, 23 Sep 2009) $
*/
-public class VocabularyServiceTest extends AbstractServiceTest {
+public class VocabularyServiceTest extends AbstractServiceTestImpl {
private final Logger logger =
LoggerFactory.getLogger(VocabularyServiceTest.class);
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class)
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class)
public void create(String testName) throws Exception {
// Perform setup, such as initializing the type of service request
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void createItem(String testName) {
setupCreate(testName);
}
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "createItem"})
public void createList(String testName) throws Exception {
for (int i = 0; i < 3; i++) {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create"})
public void read(String testName) throws Exception {
}
*/
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "read"})
public void readItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void readNonExistent(String testName) {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "readNonExistent"})
public void readItemNonExistent(String testName) {
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createList", "read"})
public void readList(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"read"})
public void update(String testName) throws Exception {
"Data in updated object did not match submitted data.");
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"readItem", "update"})
public void updateItem(String testName) throws Exception {
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"update", "testSubmitRequest"})
public void updateNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"updateItem", "testItemSubmitRequest"})
public void updateNonExistentItem(String testName) throws Exception {
// ---------------------------------------------------------------
// Success outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"create", "readList", "testSubmitRequest", "update"})
public void delete(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"createItem", "readItemList", "testItemSubmitRequest",
"updateItem"})
public void deleteItem(String testName) throws Exception {
// Failure outcomes
@Override
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"delete"})
public void deleteNonExistent(String testName) throws Exception {
Assert.assertEquals(statusCode, EXPECTED_STATUS_CODE);
}
- @Test(dataProvider="testName", dataProviderClass=AbstractServiceTest.class,
+ @Test(dataProvider="testName", dataProviderClass=AbstractServiceTestImpl.class,
dependsOnMethods = {"deleteItem"})
public void deleteNonExistentItem(String testName) {
import javax.ws.rs.core.UriInfo;
import org.collectionspace.services.VocabularyItemJAXBSchema;
-import org.collectionspace.services.common.AbstractCollectionSpaceResource;
+import org.collectionspace.services.common.AbstractCollectionSpaceResourceImpl;
import org.collectionspace.services.common.ClientType;
import org.collectionspace.services.common.ServiceMain;
import org.collectionspace.services.common.context.MultipartServiceContext;
@Path("/vocabularies")
@Consumes("multipart/mixed")
@Produces("multipart/mixed")
-public class VocabularyResource extends AbstractCollectionSpaceResource {
+public class VocabularyResource extends AbstractCollectionSpaceResourceImpl {
private final static String vocabularyServiceName = "vocabularies";
private final static String vocabularyItemServiceName = "vocabularyitems";
import org.collectionspace.services.vocabulary.VocabulariesCommonList;
import org.collectionspace.services.vocabulary.VocabulariesCommonList.VocabularyListItem;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.DocumentModelList;
* $LastChangedDate: $
*/
public class VocabularyDocumentModelHandler
- extends RemoteDocumentModelHandler<VocabulariesCommon, VocabulariesCommonList> {
+ extends RemoteDocumentModelHandlerImpl<VocabulariesCommon, VocabulariesCommonList> {
private final Logger logger = LoggerFactory.getLogger(VocabularyDocumentModelHandler.class);
/**
import org.collectionspace.services.VocabularyItemJAXBSchema;
import org.collectionspace.services.common.document.DocumentWrapper;
-import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandler;
+import org.collectionspace.services.nuxeo.client.java.RemoteDocumentModelHandlerImpl;
import org.collectionspace.services.nuxeo.util.NuxeoUtils;
import org.collectionspace.services.vocabulary.VocabularyitemsCommon;
import org.collectionspace.services.vocabulary.VocabularyitemsCommonList;
* $LastChangedDate: $
*/
public class VocabularyItemDocumentModelHandler
- extends RemoteDocumentModelHandler<VocabularyitemsCommon, VocabularyitemsCommonList> {
+ extends RemoteDocumentModelHandlerImpl<VocabularyitemsCommon, VocabularyitemsCommonList> {
private final Logger logger = LoggerFactory.getLogger(VocabularyItemDocumentModelHandler.class);
/**
projects / tmp / jakarta-migration.git / commitdiff