/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* 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.apache.juddi.datastore.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Vector;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.juddi.datastore.DataStore;
import org.apache.juddi.datatype.Address;
import org.apache.juddi.datatype.CategoryBag;
import org.apache.juddi.datatype.DiscoveryURLs;
import org.apache.juddi.datatype.IdentifierBag;
import org.apache.juddi.datatype.KeyedReference;
import org.apache.juddi.datatype.OverviewDoc;
import org.apache.juddi.datatype.SharedRelationships;
import org.apache.juddi.datatype.TModelBag;
import org.apache.juddi.datatype.assertion.PublisherAssertion;
import org.apache.juddi.datatype.binding.BindingTemplate;
import org.apache.juddi.datatype.binding.BindingTemplates;
import org.apache.juddi.datatype.binding.InstanceDetails;
import org.apache.juddi.datatype.binding.TModelInstanceDetails;
import org.apache.juddi.datatype.binding.TModelInstanceInfo;
import org.apache.juddi.datatype.business.BusinessEntity;
import org.apache.juddi.datatype.business.Contact;
import org.apache.juddi.datatype.business.Contacts;
import org.apache.juddi.datatype.publisher.Publisher;
import org.apache.juddi.datatype.request.FindQualifiers;
import org.apache.juddi.datatype.response.AssertionStatusItem;
import org.apache.juddi.datatype.response.BusinessInfo;
import org.apache.juddi.datatype.response.CompletionStatus;
import org.apache.juddi.datatype.response.PublisherInfo;
import org.apache.juddi.datatype.response.RelatedBusinessInfo;
import org.apache.juddi.datatype.response.ServiceInfo;
import org.apache.juddi.datatype.response.ServiceInfos;
import org.apache.juddi.datatype.response.TModelInfo;
import org.apache.juddi.datatype.service.BusinessService;
import org.apache.juddi.datatype.service.BusinessServices;
import org.apache.juddi.datatype.tmodel.TModel;
import org.apache.juddi.error.RegistryException;
import org.apache.juddi.error.UnknownUserException;
import org.apache.juddi.util.Config;
import org.apache.juddi.util.jdbc.ConnectionManager;
import org.apache.juddi.util.jdbc.Transaction;
import org.apache.juddi.uuidgen.UUIDGen;
import org.apache.juddi.uuidgen.UUIDGenFactory;
/**
* @author Steve Viens (sviens@apache.org)
* @author Anil Saldhana (anil@apache.org)
*/
public class JDBCDataStore implements DataStore
{
// private reference to the jUDDI logger
private static Log log = LogFactory.getLog(JDBCDataStore.class);
// private db connection associated with this datastore
private Connection connection = null;
// private XA transaxtion object
private Transaction transaction = null;
/**
* Create a new JDBCDataStore and aquire a JDBC
* connection from the connection pool.
*/
public JDBCDataStore()
{
try {
this.connection = ConnectionManager.acquireConnection();
}
catch(SQLException sqlex) {
log.error("Exception occured while attempting to " +
"aquire a JDBC connection: "+sqlex.getMessage(),sqlex);
}
}
/**
* Release all JDBC connections used by this
* JDBCDataStore back into the connection pool.
*/
public void release()
{
try {
if (connection != null)
{
this.connection.close();
this.connection = null;
}
}
catch(SQLException sqlex) {
log.error("Exception occured while attempting to " +
"close a JDBC connection: "+sqlex.getMessage());
}
}
/**
*
*/
public Connection getConnection()
{
return this.connection;
}
/**
* begin a new transaction
*/
public void beginTrans()
throws org.apache.juddi.error.RegistryException
{
try {
this.transaction = new Transaction();
this.transaction.begin(connection);
}
catch(SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
/**
* commit on all connections.
*/
public void commit()
throws org.apache.juddi.error.RegistryException
{
try {
this.transaction.commit();
}
catch(SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
/**
* rollback on all connections.
*/
public void rollback()
throws org.apache.juddi.error.RegistryException
{
try {
this.transaction.rollback();
}
catch(SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
/**
* verify that the individual or system identified by
* the 'publisherID' is a valid jUDDI user (aka publisher).
*
* @param publisherID
* @return publisher
* @throws RegistryException
*/
public Publisher getPublisher(String publisherID)
throws RegistryException
{
// a publisherID must be specified.
if (publisherID == null)
return null;
Publisher publisher = null;
try {
publisher = PublisherTable.select(publisherID,connection);
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
return publisher;
}
/**
* Will return true if the publisherID parameter specified has been tagged
* with registry administrator priviledges otherwise returns false. An
* Unknown user exception is thrown if the publisherID specified is null,
* blank or does not exist (can't be found in the PUBLISHER table).
*
* @param publisherID
* @return Returns true if publisherID parameter specified has jUDDI
* administrator priv's otherwise returns false.
* @throws RegistryException
*/
public boolean isAdministrator(String publisherID)
throws org.apache.juddi.error.RegistryException
{
if ((publisherID == null) || (publisherID.length() == 0))
throw new UnknownUserException("publisherID = "+publisherID);
try
{
Publisher publisher = PublisherTable.select(publisherID,connection);
if (publisher == null)
throw new UnknownUserException("publisherID = "+publisherID);
else
return publisher.isAdmin();
}
catch(java.sql.SQLException sqlex)
{
log.error(sqlex.getMessage());
throw new RegistryException(sqlex);
}
}
/**
* Will return true if the publisherID parameter specified is
* currently enabled otherwise returns false. An UnknownUserException
* is thrown if the publisherID specified is null, blank or does not
* exist (can't be found in the PUBLISHER table).
*
* @param publisherID
* @return Returns true if publisherID parameter specified has jUDDI
* administrator priv's otherwise returns false.
* @throws RegistryException
*/
public boolean isEnabled(String publisherID)
throws org.apache.juddi.error.RegistryException
{
if ((publisherID == null) || (publisherID.length() == 0))
throw new UnknownUserException("publisherID = "+publisherID);
try
{
Publisher publisher = PublisherTable.select(publisherID,connection);
if (publisher == null)
throw new UnknownUserException("publisherID = "+publisherID);
else
return publisher.isEnabled();
}
catch(java.sql.SQLException sqlex)
{
log.error(sqlex.getMessage());
throw new RegistryException(sqlex);
}
}
/**
*
* @param publisher
* @return String
* @throws RegistryException
*/
public String generateToken(Publisher publisher)
throws RegistryException
{
UUIDGen uuidgen = UUIDGenFactory.getUUIDGen();
String token = "authToken:"+uuidgen.uuidgen();
log.info("Generated token '"+token+"' for user: '" +
publisher.getPublisherID()+"/"+publisher.getName()+"'");
return token;
}
/**
*
*/
public void storeAuthToken(String token,Publisher publisher)
throws org.apache.juddi.error.RegistryException
{
if ((token != null) && (publisher != null))
{
try {
AuthTokenTable.insert(token,publisher,connection);
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
}
/**
*
*/
public void retireAuthToken(String token)
throws org.apache.juddi.error.RegistryException
{
if (token != null)
{
try {
AuthTokenTable.invalidate(token,connection);
AuthTokenTable.touch(token,connection);
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
}
/**
*
*/
public Publisher getAuthTokenPublisher(String token)
throws org.apache.juddi.error.RegistryException
{
Publisher publisher = null;
if (token != null)
{
try {
publisher = AuthTokenTable.selectPublisher(token,connection);
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
return publisher;
}
/**
*
*/
public boolean isAuthTokenExpired(String token)
throws org.apache.juddi.error.RegistryException
{
boolean expired = false;
if (token != null)
{
try
{
long tokenState = AuthTokenTable.selectTokenState(token, connection);
if (tokenState <= 0) {
return expired = true;
}
long lastUsed = AuthTokenTable.selectLastUsed(token,connection);
if (lastUsed > 0) // -1 is returned when token isn't found
{
long timeOut = Config.getLongProperty("juddi.authTokenTimeout",3600) * 1000L; // convert from seconds to milliseconds
long currTime = System.currentTimeMillis();
if ((currTime-lastUsed) >= timeOut)
expired = true;
}
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
return expired;
}
/**
*
*/
public void touchAuthToken(String token)
throws org.apache.juddi.error.RegistryException
{
if (token != null)
{
try {
AuthTokenTable.touch(token,connection);
}
catch(java.sql.SQLException sqlex) {
throw new RegistryException(sqlex);
}
}
}
/**
*
*/
public void saveBusiness(BusinessEntity business,String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((business != null) && (connection != null))
{
String businessKey = business.getBusinessKey();
// insert the BusinessEntity object
BusinessEntityTable.insert(business,publisherID,connection);
// insert all of the BusinessEntity Name objects
if (business.getNameVector() != null)
BusinessNameTable.insert(businessKey,business.getNameVector(),connection);
// insert all of the BusinessEntity Description objects
if (business.getDescriptionVector() != null)
BusinessDescTable.insert(businessKey,business.getDescriptionVector(),connection);
// insert the BusinessEntity's IdentiferBag KeyedReferences
IdentifierBag idBag = business.getIdentifierBag();
if ((idBag != null) && (idBag.getKeyedReferenceVector() != null))
BusinessIdentifierTable.insert(businessKey,idBag.getKeyedReferenceVector(),connection);
// insert the BusinessEntity's CategoryBag KeyedReferences
CategoryBag catBag = business.getCategoryBag();
if ((catBag != null) && (catBag.getKeyedReferenceVector() != null))
BusinessCategoryTable.insert(businessKey,catBag.getKeyedReferenceVector(),connection);
// insert the BusinessEntity's DiscoveryURLs
DiscoveryURLs discURLs = business.getDiscoveryURLs();
if ((discURLs != null) && (discURLs.getDiscoveryURLVector() != null))
DiscoveryURLTable.insert(businessKey,discURLs.getDiscoveryURLVector(),connection);
// insert the BusinessEntity's Contact objects & information
Contacts contacts = business.getContacts();
if (contacts != null)
{
Vector contactVector = contacts.getContactVector();
if ((contactVector != null) && (contactVector.size() > 0))
{
// insert the BusinessEntity's Contact objects
ContactTable.insert(businessKey,contacts.getContactVector(),connection);
// insert the BusinessEntity's Contact Phone, Address and Email Info
int listSize = contactVector.size();
for (int contactID=0; contactID<listSize; contactID++)
{
Contact contact = (Contact)contactVector.elementAt(contactID);
ContactDescTable.insert(businessKey,contactID,contact.getDescriptionVector(),connection);
EmailTable.insert(businessKey,contactID,contact.getEmailVector(),connection);
PhoneTable.insert(businessKey,contactID,contact.getPhoneVector(),connection);
// insert the Contact's AddressLine objects
Vector addrList = contact.getAddressVector();
if ((addrList != null) && (addrList.size() > 0))
{
AddressTable.insert(businessKey,contactID,addrList,connection);
for (int addrID=0; addrID<addrList.size(); addrID++)
{
Address address = (Address)addrList.elementAt(addrID);
AddressLineTable.insert(businessKey,contactID,addrID,address.getAddressLineVector(),connection);
}
}
}
}
}
// 'save' the BusinessEntity's BusinessService objects
BusinessServices services = business.getBusinessServices();
if ((services != null) && (services.getBusinessServiceVector() != null))
{
UUIDGen uuidgen = UUIDGenFactory.getUUIDGen();
Vector serviceVector = services.getBusinessServiceVector();
int serviceListSize = serviceVector.size();
for (int j=0; j<serviceListSize; j++)
{
BusinessService service = (BusinessService)serviceVector.elementAt(j);
service.setBusinessKey(businessKey);
// create a new key if serviceKey isn't specified
String serviceKey = service.getServiceKey();
if ((serviceKey == null) || (serviceKey.length() == 0)) {
service.setServiceKey(uuidgen.uuidgen());
}
saveService(service);
}
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public BusinessEntity fetchBusiness(String businessKey)
throws org.apache.juddi.error.RegistryException
{
BusinessEntity business = null;
try
{
if ((businessKey != null) && (connection != null))
{
business = BusinessEntityTable.select(businessKey,connection);
business.setNameVector(BusinessNameTable.select(businessKey,connection));
business.setDescriptionVector(BusinessDescTable.select(businessKey,connection));
Vector idVector = BusinessIdentifierTable.select(businessKey,connection);
if (idVector.size() > 0)
{
IdentifierBag identifierBag = new IdentifierBag();
identifierBag.setKeyedReferenceVector(idVector);
business.setIdentifierBag(identifierBag);
}
Vector catVector = BusinessCategoryTable.select(businessKey,connection);
if (catVector.size() > 0)
{
CategoryBag categoryBag = new CategoryBag();
categoryBag.setKeyedReferenceVector(catVector);
business.setCategoryBag(categoryBag);
}
DiscoveryURLs discoveryURLs = new DiscoveryURLs();
discoveryURLs.setDiscoveryURLVector(DiscoveryURLTable.select(businessKey,connection));
business.setDiscoveryURLs(discoveryURLs);
// 'select' the BusinessEntity's Contact objects
Vector contactList = ContactTable.select(businessKey,connection);
for (int contactID=0; contactID<contactList.size(); contactID++)
{
Contact contact = (Contact)contactList.elementAt(contactID);
contact.setPhoneVector(PhoneTable.select(businessKey,contactID,connection));
contact.setEmailVector(EmailTable.select(businessKey,contactID,connection));
Vector addressList = AddressTable.select(businessKey,contactID,connection);
for (int addressID=0; addressID<addressList.size(); addressID++)
{
Address address = (Address)addressList.elementAt(addressID);
address.setAddressLineVector(AddressLineTable.select(businessKey,contactID,addressID,connection));
}
contact.setAddressVector(addressList);
}
Contacts contacts = new Contacts();
contacts.setContactVector(contactList);
business.setContacts(contacts);
// 'fetch' the BusinessEntity's BusinessService objects
Vector serviceVector = fetchServiceByBusinessKey(businessKey);
BusinessServices services = new BusinessServices();
services.setBusinessServiceVector(serviceVector);
business.setBusinessServices(services);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return business;
}
/**
*
*/
public void deleteBusiness(String businessKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((businessKey != null) && (connection != null))
{
// delete the BusinessEntity's Services (and dependents)
deleteServiceByBusinessKey(businessKey);
// delete the dependents of BusinessEntity
AddressLineTable.delete(businessKey,connection);
AddressTable.delete(businessKey,connection);
EmailTable.delete(businessKey,connection);
PhoneTable.delete(businessKey,connection);
ContactDescTable.delete(businessKey,connection);
ContactTable.delete(businessKey,connection);
DiscoveryURLTable.delete(businessKey,connection);
BusinessIdentifierTable.delete(businessKey,connection);
BusinessCategoryTable.delete(businessKey,connection);
BusinessDescTable.delete(businessKey,connection);
BusinessNameTable.delete(businessKey,connection);
// finally, delete the BusinessEntity itself.
BusinessEntityTable.delete(businessKey,connection);
}
}
catch(java.sql.SQLException sqlex)
{
log.error(sqlex.getMessage(),sqlex);
throw new RegistryException(sqlex);
}
}
/**
*
*/
public boolean isBusinessPublisher(String businessKey,String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisherID != null) && (businessKey != null) && (connection != null))
return BusinessEntityTable.verifyOwnership(businessKey,publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public boolean isValidBusinessKey(String businessKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((businessKey != null) && (connection != null) &&
(BusinessEntityTable.select(businessKey,connection) != null))
return true;
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public void saveService(BusinessService service)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((service != null) && (connection != null))
{
String serviceKey = service.getServiceKey();
// insert the BusinessService object
BusinessServiceTable.insert(service,connection);
// insert all of the BusinessService's Name objects
if (service.getNameVector() != null)
ServiceNameTable.insert(serviceKey,service.getNameVector(),connection);
// insert all of the BusinessService's Description objects
if (service.getDescriptionVector() != null)
ServiceDescTable.insert(serviceKey,service.getDescriptionVector(),connection);
// insert the BusinessService's CategoryBag KeyedReferences
CategoryBag catBag = service.getCategoryBag();
if ((catBag != null) && (catBag.getKeyedReferenceVector() != null))
ServiceCategoryTable.insert(serviceKey,catBag.getKeyedReferenceVector(),connection);
// extract the binding template objects
BindingTemplates bindings = service.getBindingTemplates();
if (bindings == null)
return; // no binding templates were present
// convert the binding templates to a vector of templates
Vector bindingList = bindings.getBindingTemplateVector();
if (bindingList == null)
return; // a binding template vector wasn't found
// aquire a reference to the shared UUIDGen instance
UUIDGen uuidgen = UUIDGenFactory.getUUIDGen();
// save all of the binding templates that were found
int listSize = bindingList.size();
for (int i=0; i<listSize; i++)
{
BindingTemplate binding = (BindingTemplate)bindingList.elementAt(i);
binding.setServiceKey(serviceKey);
// create a new key if bindingKey isn't specified
String bindingKey = binding.getBindingKey();
if ((bindingKey == null) || (bindingKey.length() == 0)) {
binding.setBindingKey(uuidgen.uuidgen());
}
saveBinding(binding);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public BusinessService fetchService(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
BusinessService service = null;
try
{
if ((serviceKey != null) && (connection != null))
{
service = BusinessServiceTable.select(serviceKey,connection);
service.setNameVector(ServiceNameTable.select(serviceKey,connection));
service.setDescriptionVector(ServiceDescTable.select(serviceKey,connection));
Vector catVector = ServiceCategoryTable.select(serviceKey,connection);
if (catVector.size() > 0)
{
CategoryBag bag = new CategoryBag();
bag.setKeyedReferenceVector(catVector);
service.setCategoryBag(bag);
}
// 'fetch' the BusinessService's BindingTemplate objects
Vector bindingVector = fetchBindingByServiceKey(serviceKey);
BindingTemplates bindings = new BindingTemplates();
bindings.setBindingTemplateVector(bindingVector);
service.setBindingTemplates(bindings);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return service;
}
/**
*
*/
public void deleteService(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((serviceKey != null) && (connection != null))
{
// delete the BusinessService's BindingTemplates (and dependents)
deleteBindingByServiceKey(serviceKey);
// delete the immediate dependents of BusinessService
ServiceNameTable.delete(serviceKey,connection);
ServiceDescTable.delete(serviceKey,connection);
ServiceCategoryTable.delete(serviceKey,connection);
// finally, delete the BusinessService itself.
BusinessServiceTable.delete(serviceKey,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
private Vector fetchServiceByBusinessKey(String businessKey)
throws org.apache.juddi.error.RegistryException
{
Vector serviceList = new Vector();
try
{
if ((businessKey != null) && (connection != null))
{
Vector tempList = BusinessServiceTable.selectByBusinessKey(businessKey,connection);
for (int i=0; i<tempList.size(); i++)
{
BusinessService service = (BusinessService)tempList.elementAt(i);
serviceList.add(fetchService(service.getServiceKey()));
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return serviceList;
}
/**
*
*/
private void deleteServiceByBusinessKey(String businessKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((businessKey != null) && (connection != null))
{
// obtain a vector of BusinessServices associated with the BusinessKey
Vector services = BusinessServiceTable.selectByBusinessKey(businessKey,connection);
// loop through the vector deleting each server in turn
int listSize = services.size();
for (int i=0; i<listSize; i++)
{
BusinessService service = (BusinessService)services.elementAt(i);
deleteService(service.getServiceKey());
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public boolean isValidServiceKey(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((serviceKey != null) && (connection != null) &&
(BusinessServiceTable.select(serviceKey,connection) != null))
return true;
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public boolean isServicePublisher(String serviceKey,String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisherID != null) && (serviceKey != null) && (connection != null))
return BusinessServiceTable.verifyOwnership(serviceKey,publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public void saveBinding(BindingTemplate binding)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((binding != null) && (connection != null))
{
String bindingKey = binding.getBindingKey();
// insert the BindingTemplate object
BindingTemplateTable.insert(binding,connection);
// insert the BindingTemplate's CategoryBag KeyedReferences (UDDI v3.0)
CategoryBag catBag = binding.getCategoryBag();
if ((catBag != null) && (catBag.getKeyedReferenceVector() != null))
BindingCategoryTable.insert(bindingKey,catBag.getKeyedReferenceVector(),connection);
// insert all of the BindingTemplate's Description objects
if (binding.getDescriptionVector() != null)
BindingDescTable.insert(bindingKey,binding.getDescriptionVector(),connection);
TModelInstanceDetails details = binding.getTModelInstanceDetails();
if (details == null)
return;
Vector detailsVector = details.getTModelInstanceInfoVector();
if (detailsVector == null)
return;
TModelInstanceInfoTable.insert(bindingKey,detailsVector,connection);
// save all of the BindingTemplate objects
Vector infoList = details.getTModelInstanceInfoVector();
int listSize = infoList.size();
for (int infoID=0; infoID<listSize; infoID++)
{
TModelInstanceInfo info = (TModelInstanceInfo)infoList.elementAt(infoID);
TModelInstanceInfoDescTable.insert(binding.getBindingKey(),infoID,info.getDescriptionVector(),connection);
InstanceDetails instDetails = info.getInstanceDetails();
if (instDetails != null)
{
InstanceDetailsDescTable.insert(binding.getBindingKey(),infoID,instDetails.getDescriptionVector(),connection);
OverviewDoc overDoc = instDetails.getOverviewDoc();
if (overDoc != null)
InstanceDetailsDocDescTable.insert(binding.getBindingKey(),infoID,overDoc.getDescriptionVector(),connection);
}
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public BindingTemplate fetchBinding(String bindingKey)
throws org.apache.juddi.error.RegistryException
{
BindingTemplate binding = null;
try
{
if ((bindingKey != null) && (connection != null))
{
// fetch the BindingTempate and it's Description Vector
binding = BindingTemplateTable.select(bindingKey,connection);
binding.setDescriptionVector(BindingDescTable.select(bindingKey,connection));
// fetch the BindingTemplate's CategoryBag (UDDI v3.0)
CategoryBag bag = new CategoryBag();
bag.setKeyedReferenceVector(BindingCategoryTable.select(bindingKey,connection));
binding.setCategoryBag(bag);
// fetch the BindingTemplate's TModelInstanceInfos
Vector infoVector = TModelInstanceInfoTable.select(bindingKey,connection);
if (infoVector != null)
{
int vectorSize = infoVector.size();
for (int infoID=0; infoID<vectorSize; infoID++)
{
TModelInstanceInfo info = (TModelInstanceInfo)infoVector.elementAt(infoID);
// fetch the TModelInstanceInfo Descriptions
info.setDescriptionVector(TModelInstanceInfoDescTable.select(bindingKey,infoID,connection));
InstanceDetails instDetails = info.getInstanceDetails();
if (instDetails != null)
{
// fetch the InstanceDetail Descriptions
instDetails.setDescriptionVector(InstanceDetailsDescTable.select(bindingKey,infoID,connection));
// fetch the InstanceDetail OverviewDoc Descrptions
OverviewDoc overDoc = instDetails.getOverviewDoc();
if (overDoc != null)
{
overDoc.setDescriptionVector(InstanceDetailsDocDescTable.select(bindingKey,infoID,connection));
instDetails.setOverviewDoc(overDoc);
}
}
}
TModelInstanceDetails details = new TModelInstanceDetails();
details.setTModelInstanceInfoVector(infoVector);
binding.setTModelInstanceDetails(details);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return binding;
}
/**
*
*/
public void deleteBinding(String bindingKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((bindingKey != null) && (connection != null))
{
// delete the immediate dependents of BindingTemplate
BindingDescTable.delete(bindingKey,connection);
BindingCategoryTable.delete(bindingKey,connection); // UDDI v3.0
TModelInstanceInfoDescTable.delete(bindingKey,connection);
InstanceDetailsDocDescTable.delete(bindingKey,connection);
InstanceDetailsDescTable.delete(bindingKey,connection);
TModelInstanceInfoTable.delete(bindingKey,connection);
// finally, delete the BindingTemplate itself.
BindingTemplateTable.delete(bindingKey,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
private Vector fetchBindingByServiceKey(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
Vector bindingList = new Vector();
try
{
if ((serviceKey != null) && (connection != null))
{
Vector tempList = BindingTemplateTable.selectByServiceKey(serviceKey,connection);
for (int i=0; i<tempList.size(); i++)
{
BindingTemplate binding = (BindingTemplate)tempList.elementAt(i);
bindingList.add(fetchBinding(binding.getBindingKey()));
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return bindingList;
}
/**
*
*/
private void deleteBindingByServiceKey(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((serviceKey != null) && (connection != null))
{
// obtain a vector of BusinessServices associated with the BusinessKey
Vector bindings = BindingTemplateTable.selectByServiceKey(serviceKey,connection);
// loop through the vector deleting each server in turn
int listSize = bindings.size();
for (int i=0; i<listSize; i++)
{
BindingTemplate binding = (BindingTemplate)bindings.elementAt(i);
deleteBinding(binding.getBindingKey());
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public boolean isValidBindingKey(String bindingKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((bindingKey != null) && (connection != null) &&
(BindingTemplateTable.select(bindingKey,connection) != null))
return true;
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public boolean isBindingPublisher(String bindingKey,String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisherID != null) && (bindingKey != null) && (connection != null))
return BindingTemplateTable.verifyOwnership(bindingKey,publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public void saveTModel(TModel tModel,String authorizedUserID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((tModel != null) && (connection != null))
{
String tModelKey = tModel.getTModelKey();
// insert the TModel object
TModelTable.insert(tModel,authorizedUserID,connection);
// insert all of the TModel Description objects
if (tModel.getDescriptionVector() != null)
TModelDescTable.insert(tModelKey,tModel.getDescriptionVector(),connection);
// insert the TModel's IdentiferBag KeyedReferences
IdentifierBag idBag = tModel.getIdentifierBag();
if ((idBag != null) && (idBag.getKeyedReferenceVector() != null))
TModelIdentifierTable.insert(tModelKey,idBag.getKeyedReferenceVector(),connection);
// insert the TModel's CategoryBag KeyedReferences
CategoryBag catBag = tModel.getCategoryBag();
if ((catBag != null) && (catBag.getKeyedReferenceVector() != null))
TModelCategoryTable.insert(tModelKey,catBag.getKeyedReferenceVector(),connection);
// insert the TModel's OverviewDoc & Descriptions
OverviewDoc overDoc = tModel.getOverviewDoc();
if ((overDoc != null) && (overDoc.getDescriptionVector() != null))
{
// insert the TModel's OverviewDoc Descriptions
Vector descVector = overDoc.getDescriptionVector();
if ((descVector != null) && (descVector.size() > 0))
TModelDocDescTable.insert(tModelKey,descVector,connection);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public TModel fetchTModel(String tModelKey)
throws org.apache.juddi.error.RegistryException
{
TModel tModel = null;
try
{
if ((tModelKey != null) && (connection != null))
{
tModel = TModelTable.select(tModelKey,connection);
if (tModel != null)
{
tModel.setDescriptionVector(TModelDescTable.select(tModelKey,connection));
// fetch the TModel CategoryBag
Vector catVector = TModelCategoryTable.select(tModelKey,connection);
if ((catVector != null) && (catVector.size() != 0))
{
CategoryBag catBag = new CategoryBag();
catBag.setKeyedReferenceVector(catVector);
tModel.setCategoryBag(catBag);
}
// fetch the TModel IdentifierBag
Vector idVector = TModelIdentifierTable.select(tModelKey,connection);
if ((idVector != null) && (idVector.size() != 0))
{
IdentifierBag idBag = new IdentifierBag();
idBag.setKeyedReferenceVector(idVector);
tModel.setIdentifierBag(idBag);
}
// fetch the TModel OverviewDoc & OverviewDoc Descrptions
OverviewDoc overDoc = tModel.getOverviewDoc();
if (overDoc != null)
{
overDoc.setDescriptionVector(TModelDocDescTable.select(tModelKey,connection));
tModel.setOverviewDoc(overDoc);
}
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return tModel;
}
/**
*
*/
public void deleteTModel(String tModelKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((tModelKey != null) && (connection != null))
{
// delete the dependents of TModel
TModelCategoryTable.delete(tModelKey,connection);
TModelDescTable.delete(tModelKey,connection);
TModelDocDescTable.delete(tModelKey,connection);
TModelIdentifierTable.delete(tModelKey,connection);
// delete the TModel
TModelTable.delete(tModelKey,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public void markTModelAsDeleted(String tModelKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((tModelKey != null) && (connection != null))
{
// mark the TModel as deleted
TModelTable.markAsDeleted(tModelKey,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public boolean isValidTModelKey(String tModelKey)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((tModelKey != null) && (connection != null) &&
(TModelTable.select(tModelKey,connection) != null))
return true;
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public boolean isTModelPublisher(String tModelKey,String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisherID != null) && (tModelKey != null) && (connection != null))
return TModelTable.verifyOwnership(tModelKey,publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
// default to false
return false;
}
/**
*
*/
public BusinessInfo fetchBusinessInfo(String businessKey)
throws org.apache.juddi.error.RegistryException
{
BusinessInfo info = null;
if ((businessKey != null) && (connection != null))
{
try
{
info = new BusinessInfo();
info.setBusinessKey(businessKey);
info.setNameVector(BusinessNameTable.select(businessKey,connection));
info.setDescriptionVector(BusinessDescTable.select(businessKey,connection));
info.setServiceInfos(fetchServiceInfosByBusinessKey(businessKey));
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
return info;
}
/**
*
*/
private ServiceInfos fetchServiceInfosByBusinessKey(String businessKey)
throws org.apache.juddi.error.RegistryException
{
Vector serviceInfoVector = new Vector();
if ((businessKey != null) && (connection != null))
{
try
{
Vector services = BusinessServiceTable.selectByBusinessKey(businessKey,connection);
for (int i=0; i<services.size(); i++)
{
// make a reference to this BusinessServce to
// easily harvest ServiceInfo data from it.
BusinessService service = (BusinessService)services.elementAt(i);
String serviceKey = service.getServiceKey();
// okay, create a new ServiceInfo
ServiceInfo info = new ServiceInfo();
info.setServiceKey(serviceKey);
info.setBusinessKey(businessKey);
info.setNameVector(ServiceNameTable.select(serviceKey,connection));
// add this ServiceInfo to the ServiceInfo vector
serviceInfoVector.add(info);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
ServiceInfos serviceInfos = new ServiceInfos();
serviceInfos.setServiceInfoVector(serviceInfoVector);
return serviceInfos;
}
/**
*
*/
public ServiceInfo fetchServiceInfo(String serviceKey)
throws org.apache.juddi.error.RegistryException
{
ServiceInfo info = null;
if ((serviceKey != null) && (connection != null))
{
try
{
BusinessService service = BusinessServiceTable.select(serviceKey,connection);
if (service != null)
{
info = new ServiceInfo();
info.setServiceKey(service.getServiceKey());
info.setBusinessKey(service.getBusinessKey());
info.setNameVector(ServiceNameTable.select(serviceKey,connection));
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
return info;
}
/**
*
*/
public TModelInfo fetchTModelInfo(String tModelKey)
throws org.apache.juddi.error.RegistryException
{
TModelInfo info = null;
if ((tModelKey != null) && (connection != null))
{
try
{
TModel tModel = TModelTable.select(tModelKey,connection);
info = new TModelInfo();
info.setTModelKey(tModelKey);
info.setName(tModel.getName());
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
return info;
}
/**
*
*/
public Vector findBusiness( Vector nameVector,
DiscoveryURLs discoveryURLs,
IdentifierBag identifierBag,
CategoryBag categoryBag,
TModelBag tModelBag,
FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
if ((discoveryURLs != null) && (discoveryURLs.size() > 0))
keyVector = FindBusinessByDiscoveryURLQuery.select(discoveryURLs,keyVector,findQualifiers,connection);
if ((findQualifiers != null) && (findQualifiers.orAllKeys))
{
// orAllKeys = Use logical "OR" when searching by categoryBag
// or tModelBag. See UDDI v2.04 API Specification - Appendix E.
if ((tModelBag != null) && (tModelBag.size() > 0))
keyVector = FindBusinessByTModelKeyQuery.select(tModelBag,keyVector,findQualifiers,connection);
if ((categoryBag != null) && (categoryBag.size() > 0))
keyVector = FindBusinessByCategoryQuery.select(categoryBag,keyVector,findQualifiers,connection);
}
else
{
// Default UDDI v2 behavior: Use logical "AND" when searching
// by categoryBagor tModelBag. See Appendix E of the UDDI v2.04
// API Specification.
if ((tModelBag != null) && (tModelBag.size() > 0))
{
Vector tModelKeyVector = tModelBag.getTModelKeyVector();
if (tModelKeyVector != null)
{
for (int i=0; i<tModelKeyVector.size(); i++)
{
String tModelKey = (String)tModelKeyVector.elementAt(i);
keyVector = FindBusinessByTModelKeyQuery.select(tModelKey,keyVector,findQualifiers,connection);
}
}
}
if ((categoryBag != null) && (categoryBag.size() > 0))
{
Vector keyedRefVector = categoryBag.getKeyedReferenceVector();
if (keyedRefVector != null)
{
for (int i=0; i<keyedRefVector.size(); i++)
{
KeyedReference keyedRef = (KeyedReference)keyedRefVector.elementAt(i);
keyVector = FindBusinessByCategoryQuery.select(keyedRef,keyVector,findQualifiers,connection);
}
}
}
} // end else
if ((identifierBag != null) && (identifierBag.size() > 0))
keyVector = FindBusinessByIdentifierQuery.select(identifierBag,keyVector,findQualifiers,connection);
// always perform this query - even when not searching by Name!!!
keyVector = FindBusinessByNameQuery.select(nameVector,keyVector,findQualifiers,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
*/
public Vector findService(String businessKey,
Vector nameVector,
CategoryBag categoryBag,
TModelBag tModelBag,
FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
if (businessKey != null)
keyVector = FindServiceByBusinessKeyQuery.select(businessKey,keyVector,findQualifiers,connection);
if ((findQualifiers != null) && (findQualifiers.orAllKeys))
{
// orAllKeys = Use logical "OR" when searching by categoryBag
// or tModelBag. See UDDI v2.04 API Specification - Appendix E.
if ((tModelBag != null) && (tModelBag.size() > 0))
keyVector = FindServiceByTModelKeyQuery.select(businessKey,tModelBag,keyVector,findQualifiers,connection);
if ((categoryBag != null) && (categoryBag.size() > 0))
keyVector = FindServiceByCategoryQuery.select(businessKey,categoryBag,keyVector,findQualifiers,connection);
}
else
{
// Default UDDI v2 behavior: Use logical "AND" when searching
// by categoryBagor tModelBag. See Appendix E of the UDDI v2.04
// API Specification.
if ((tModelBag != null) && (tModelBag.size() > 0))
{
Vector tModelKeyVector = tModelBag.getTModelKeyVector();
if (tModelKeyVector != null)
{
for (int i=0; i<tModelKeyVector.size(); i++)
{
String tModelKey = (String)tModelKeyVector.elementAt(i);
keyVector = FindServiceByTModelKeyQuery.select(businessKey,tModelKey,keyVector,findQualifiers,connection);
}
}
}
if ((categoryBag != null) && (categoryBag.size() > 0))
{
Vector keyedRefVector = categoryBag.getKeyedReferenceVector();
if (keyedRefVector != null)
{
for (int i=0; i<keyedRefVector.size(); i++)
{
KeyedReference keyedRef = (KeyedReference)keyedRefVector.elementAt(i);
keyVector = FindServiceByCategoryQuery.select(businessKey,keyedRef,keyVector,findQualifiers,connection);
}
}
}
} // end else
// always perform this query - even when not searching by Name!!!
keyVector = FindServiceByNameQuery.select(businessKey,nameVector,keyVector,findQualifiers,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
*/
public Vector findTModel( String name,
CategoryBag categoryBag,
IdentifierBag identifierBag,
FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
if ((findQualifiers != null) && (findQualifiers.orAllKeys))
{
// orAllKeys = Use logical "OR" when searching by category
// bag. See UDDI v2.04 API Specification - Appendix E.
//
if ((categoryBag != null) && (categoryBag.size() > 0))
keyVector = FindTModelByCategoryQuery.select(categoryBag,keyVector,findQualifiers,connection);
}
else
{
// Default UDDI v2 behavior: Use logical "AND" when searching
// by category bag. See UDDI v2.04 API Specification - Appendix E.
//
if ((categoryBag != null) && (categoryBag.size() > 0))
{
Vector keyedRefVector = categoryBag.getKeyedReferenceVector();
if (keyedRefVector != null)
{
for (int i=0; i<keyedRefVector.size(); i++)
{
KeyedReference keyedRef = (KeyedReference)keyedRefVector.elementAt(i);
keyVector = FindTModelByCategoryQuery.select(keyedRef,keyVector,findQualifiers,connection);
}
}
}
}
if ((identifierBag != null) && (identifierBag.size() > 0))
keyVector = FindTModelByIdentifierQuery.select(identifierBag,keyVector,findQualifiers,connection);
// always perform this query - even when not searching by Name!!!
keyVector = FindTModelByNameQuery.select(name,keyVector,findQualifiers,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
*/
public Vector findBinding(String serviceKey,
CategoryBag categoryBag,
TModelBag tModelBag,
FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
if (serviceKey != null)
keyVector = FindBindingByServiceKeyQuery.select(serviceKey,keyVector,findQualifiers,connection);
if ((findQualifiers != null) && (findQualifiers.orAllKeys))
{
// orAllKeys = Use logical "OR" when searching by TModel bag
// or category bag. See UDDI v2.04 API Specification - Appendix E.
if ((tModelBag != null) && (tModelBag.size() > 0))
keyVector = FindBindingByTModelKeyQuery.select(serviceKey,tModelBag,keyVector,findQualifiers,connection);
if ((categoryBag != null) && (categoryBag.size() > 0))
keyVector = FindBindingByCategoryQuery.select(serviceKey,categoryBag,keyVector,findQualifiers,connection);
}
else
{
// Default UDDI v2 behavior: Use logical "AND" when searching
// by tModel bag. See UDDI v2.04 API Specification - Appendix E.
if ((tModelBag != null) && (tModelBag.size() > 0))
{
Vector tModelKeyVector = tModelBag.getTModelKeyVector();
if (tModelKeyVector != null)
{
for (int i=0; i<tModelKeyVector.size(); i++)
{
String tModelKey = (String)tModelKeyVector.elementAt(i);
keyVector = FindBindingByTModelKeyQuery.select(serviceKey,tModelKey,keyVector,findQualifiers,connection);
}
}
}
if ((categoryBag != null) && (categoryBag.size() > 0))
{
Vector keyedRefVector = categoryBag.getKeyedReferenceVector();
if (keyedRefVector != null)
{
for (int i=0; i<keyedRefVector.size(); i++)
{
KeyedReference keyedRef = (KeyedReference)keyedRefVector.elementAt(i);
keyVector = FindBindingByCategoryQuery.select(serviceKey,keyedRef,keyVector,findQualifiers,connection);
}
}
}
}
// Steve: This fix has been replaced with the call to
// FindBindingByServiceKeyQuery found at the start of
// this method.
//
// /**
// * Anil: Only if the serviceKey is passed
// */
//
// if((serviceKey != null) && (tModelBag == null) && (categoryBag == null))
// {
// Vector bindtempVect= BindingTemplateTable.selectByServiceKey(serviceKey,connection);
// for(int i=0; bindtempVect != null && i < bindtempVect.size();i++)
// {
// BindingTemplate bt = (BindingTemplate)bindtempVect.elementAt(i);
// if(keyVector == null ) keyVector = new Vector(bindtempVect.size());
// keyVector.add(bt.getBindingKey());
// }
// }
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
* 1. Retrieve a Vector of BusinessKeys for related BusinessEntities by calling
* FindRelatedBusinessQuery.select(businessKey) or if a KeyedReference was
* specified in the query call FindRelatedBusinessQuery.selectWithKeyedRef(businessKey,KeyedReference)
*
* 2. Call FindBusinessByNameQuery.select(null,keyVector,qualifiers,connection)
* to return the Vector of relatedBusinessKeys from step 1 in the requested
* order as specified by any FindQualifiers supplied with the UDDI Request.
*
* 3. For each relatedBusinessKey returned in step 2 perform the following:
*
* 4. Create a new RelatedBusinessInfo instance.
*
* 5. Fetch the related businesses BusinessInfo instance by calling
* DataStore.fetchBusinessInfo(relatedBusinessKey) and save the Name
* Vector and Description Vector to the RelatedBusinessInfo created in
* step 4.
*
* 6. Using the businessKey passed in to the query and the relatedBusinessKey
* from the BusinessInfo fetched (step 4) get all KeyedReference instances
* for this pair of keys and add them to the RelatedBusinessInfo created
* in step 4. (only grab KeyedReference values from rows where both
* FROM_CHECK and TO_CHECK columns are = 'true'. Do this by making a call to
* PublisherAssertionTable.selectBusinessRelationships(businessKey,relatedKey)
*/
public Vector findRelatedBusinesses(String businessKey,KeyedReference keyedRef,FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
Vector infoVector = null;
try
{
// grab the keys of all businesses related to businessKey.
if (keyedRef == null)
keyVector = FindRelatedBusinessQuery.select(businessKey,connection);
else
keyVector = FindRelatedBusinessQuery.selectWithKeyedRef(businessKey,keyedRef,connection);
// returns the keys found above in the approriate order
keyVector = FindBusinessByNameQuery.select(null,keyVector,findQualifiers,connection);
// iterate through the business entity keys fetching each associated BusinessInfo.
int rowCount = keyVector.size();
infoVector = new Vector(rowCount);
for (int i=0; i<rowCount; i++)
{
String relatedKey = (String)keyVector.elementAt(i);
BusinessInfo bizInfo = fetchBusinessInfo(relatedKey);
if(bizInfo != null)
{
RelatedBusinessInfo relatedBizInfo = new RelatedBusinessInfo();
relatedBizInfo.setBusinessKey(bizInfo.getBusinessKey());
relatedBizInfo.setNameVector( bizInfo.getNameVector() );
relatedBizInfo.setDescriptionVector( bizInfo.getDescriptionVector() );
Vector keyedReferences = PublisherAssertionTable.selectRelatedBusinesses(businessKey,relatedKey,connection);
relatedBizInfo.setSharedRelationships(new SharedRelationships(keyedReferences));
infoVector.addElement(relatedBizInfo);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return infoVector;
}
/**
*
*/
public Vector findRegisteredBusinesses(String publisherID)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
// grab the keys of all BusinessEntities published by 'publisherID'.
keyVector = BusinessEntityTable.selectByPublisherID(publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
*/
public Vector findRegisteredTModels(String publisherID)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
// grab the keys of all TModels published by 'publisherID'.
keyVector = TModelTable.selectByPublisherID(publisherID,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
/**
*
* For each PublisherAssertion in the Vector of PublisherAssertions passed
* in perform the following steps:
*
* 1. Determine if the BusinessEntity specified in the 'fromKey' is
* managed by publisherID retrieved in step 1. Do this by calling:
* BusinessEntityTable.selectPublisherID(fromKey);
*
* 2. Determine if the BusinessEntity specified in the 'toKey' is
* managed by publisherID retrieved in step 1. Do this by calling:
* BusinessEntityTable.selectPublisherID(toKey);
*
* 3. If at least one of the two BusinessKeys specified in this
* PublisherAssertion is managed by providerID then check to see if
* a row already exists in the PUBLISHER_ASSERTION table by calling:
* PublisherAssertionTable.select(PublisherAssertion assertionIn)
*
* 4. If a row doesn't exist then insert a new one (set the values of the
* to_check and from_check columns appropriately based on info returned
* in steps 3 & 4.) Insert the row by calling:
* PublisherAssertionTable.insert(PublisherAssertion,fromCheck,toCheck)
*
* 5. If a row does exist and publisherID is responsible for the
* BusinessEntity identified by 'fromKey' then update the row by calling:
* PublisherAssertionTable.updateFromCheck(PublisherAssertion,true)
*
* 6. If a row does exist and publisherID is responsible for the
* BusinessEntity identified by 'toKey' then update the row by calling:
* PublisherAssertionTable.updateToCheck(PublisherAssertion,true)
*/
public void saveAssertions(String publisherID,Vector assertions)
throws org.apache.juddi.error.RegistryException
{
try
{
// iterate through the PublisherAssertion Vector
for (int i=0; i<assertions.size(); i++)
{
// grab the next PublisherAssertion and it's 'fromKey' & 'toKey' values
PublisherAssertion assertion = (PublisherAssertion)assertions.elementAt(i);
String fromKey = assertion.getFromKey();
String toKey = assertion.getToKey();
// determine if this assertion's 'fromKey' and/or 'toKey' values are
// managed by the PublisherID specified.
boolean fromCheck = BusinessEntityTable.verifyOwnership(fromKey,publisherID,connection);
boolean toCheck = BusinessEntityTable.verifyOwnership(toKey,publisherID,connection);
// if a row in the PUBLISHER_ASSERTION table doesn't yet exist then
// insert one. If a row does already exist then simply update the appropriate
// 'fromKey' and 'toKey' values.
if (PublisherAssertionTable.select(assertion,connection) == null)
PublisherAssertionTable.insert(assertion,fromCheck,toCheck,connection);
else
{
if (fromCheck)
PublisherAssertionTable.updateFromCheck(assertion,fromCheck,connection);
if (toCheck)
PublisherAssertionTable.updateToCheck(assertion,toCheck,connection);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
* For each PublisherAssertion in the Vector of PublisherAssertions passed
* in perform the following steps:
*
* 1. Determine if the BusinessEntity specified in the 'fromKey' is
* managed by publisherID retrieved in step 1. Do this by calling:
* BusinessEntityTable.selectPublisherID(fromKey);
*
* 2. If the publisherID does manage the BusinessEntity identified by
* the PublisherAssertions 'fromKey' then call the following method:
* PublisherAssertionTable.updateFromCheck(PublisherAssertion,false)
*
* 3. Determine if the BusinessEntity specified in the 'toKey' is
* managed by publisherID retrieved in step 1. Do this by calling:
* BusinessEntityTable.selectPublisherID(toKey);
*
* 4. If the publisherID does manage the BusinessEntity identified by
* the PublisherAssertions 'toKey then call the following method:
* PublisherAssertionTable.updateToCheck(PublisherAssertion,false)
*
* 5. After iterating through the entire Vector of PublisherAssertions
* call the following method: PublisherAssertionTable.deleteDeadAssertions()
*/
public void deleteAssertions(String publisherID,Vector assertions)
throws org.apache.juddi.error.RegistryException
{
try
{
// iterate through the PublisherAssertion Vector
for (int i=0; i<assertions.size(); i++)
{
// grab a reference to the next PublisherAssertion
PublisherAssertion assertion = (PublisherAssertion)assertions.elementAt(i);
// if the PublisherID is equal to the PublisherID of the BusinessEntity
// specified by the 'fromKey' then set the FROM_CHECK column to 'false'
String fromID = BusinessEntityTable.selectPublisherID(assertion.getFromKey(),connection);
if (publisherID.equalsIgnoreCase(fromID))
PublisherAssertionTable.updateFromCheck(assertion,false,connection);
// if the PublisherID is equal to the PublisherID of the BusinessEntity
// specified by the 'toKey' then set the TO_CHECK column to 'false'
String toID = BusinessEntityTable.selectPublisherID(assertion.getToKey(),connection);
if (publisherID.equalsIgnoreCase(toID))
PublisherAssertionTable.updateToCheck(assertion,false,connection);
}
// remove any invalidated rows from the PUBLISHER_ASSERTION table. An
// invalidated row is any row with a value of 'false' in both the
// FROM_KEY and TO_KEY columns.
if (assertions.size() > 0)
PublisherAssertionTable.deleteDeadAssertions(connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
* 1. Retrieve all BusinessKey's that the publisherID is responsible for
* managing by calling: BusinessEntityTable.selectByPublisherID(publisherID)
*
* 2. Retrieve all PublisherAssertion's that publisherID has made by
* calling: PublisherAssertionTable.selectAssertions(Vector) where
* 'Vector' is the collection of BusinessKey's returned in step 2.
*/
public Vector getAssertions(String publisherID)
throws org.apache.juddi.error.RegistryException
{
Vector assertions = null;
try
{
Vector keys = BusinessEntityTable.selectByPublisherID(publisherID,connection);
assertions = PublisherAssertionTable.selectAssertions(keys,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return assertions;
}
/**
*
* 1. Retrieve all PublisherAssertions associated with the publisherID
* passed in by calling DataSource.getAssertions(publisherID)
*
* 2. With the Vector of PublisherAssertions retrieved in step 1 call
* DataSource.deleteAssertions(publisherID,Vector)
*
* 3. With the Vector of PublisherAssertions passed into this method
* call: DataSource.addAssertions(publisherID,Vector)
*/
public Vector setAssertions(String publisherID,Vector newAssertions)
throws org.apache.juddi.error.RegistryException
{
// grab all existing PublisherAssertions with this publisherID
Vector oldAssertions = getAssertions(publisherID);
// delete all existing PublisherAsssertions with this publisherID
deleteAssertions(publisherID,oldAssertions);
// save all of the new PublisherAssertions
saveAssertions(publisherID,newAssertions);
return newAssertions;
}
/**
*
* 1. Retrieve Vector of BusinessKeys for BusinessEntities managed by
* publisherID by calling: BusinessEntityTable.selectByPublisherID(publisherID)
*
* 2. Call PublisherAssertionTable.selectBothKeysOwnedAssertions(Vector of BusinessKeys)
*
* 3. Call PublisherAssertionTable.selectFromKeyOwnedAssertions(Vector of BusinessKeys)
*
* 4. Call PublisherAssertionTable.selectToKeyOwnedAssertions(Vector of BusinessKeys)
*
* 5. Combine Vectors from steps 3, 4 and 5 above into one Vector of
* AssertionStatusItem instances
*
* 5. Loop through Vector from step 6 copying only AssertionStatusItem instances
* that have a CompletionStatus that matches the completionStatus requested.
*/
public Vector getAssertionStatusItems(String publisherID,String completionStatus)
throws org.apache.juddi.error.RegistryException
{
Vector items = null;
try
{
// grab a Vector of BusinessKeys managed by PublisherID
Vector keys = BusinessEntityTable.selectByPublisherID(publisherID,connection);
// grab any PublisherAssertion (as an AssertionStatusItem) that includes
// any of the BusinessKeys returned above in the TO_KEY or FROM_KEY field.
Vector allItems = new Vector();
allItems.addAll(PublisherAssertionTable.selectBothKeysOwnedAssertion(keys,connection));
allItems.addAll(PublisherAssertionTable.selectFromKeyOwnedAssertion(keys,connection));
allItems.addAll(PublisherAssertionTable.selectToKeyOwnedAssertion(keys,connection));
// if no completionStatua was passed in then simply return all
// AssertionStatusItems. Otherwise only return the ones that have
// the 'completionStatus' specified.
if ((completionStatus == null) || (completionStatus.length() == 0))
items = allItems;
else
{
// create the Vector to return
if (allItems.size() > 0)
items = new Vector();
// evaluate every AssertionStatusItem
for (int i=0; i<allItems.size(); i++)
{
AssertionStatusItem item = (AssertionStatusItem)allItems.elementAt(i);
CompletionStatus status = item.getCompletionStatus();
if (status.getValue().equalsIgnoreCase(completionStatus))
items.addElement(item);
}
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return items;
}
/**
*
*/
public void savePublisher(Publisher publisher)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisher != null) && (connection != null))
{
// create the Publisher account
PublisherTable.insert(publisher,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public void deletePublisher(String publisherID)
throws org.apache.juddi.error.RegistryException
{
try
{
if ((publisherID != null) && (connection != null))
{
// delete the Publisher account
PublisherTable.delete(publisherID,connection);
}
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
/**
*
*/
public PublisherInfo fetchPublisherInfo(String publisherID)
throws org.apache.juddi.error.RegistryException
{
PublisherInfo info = null;
if ((publisherID != null) && (connection != null))
{
try
{
Publisher publisher = PublisherTable.select(publisherID,connection);
info = new PublisherInfo();
info.setPublisherID(publisherID);
info.setNameValue(publisher.getName());
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
}
return info;
}
/**
*
*/
public Vector findPublisher(String name,FindQualifiers findQualifiers)
throws org.apache.juddi.error.RegistryException
{
Vector keyVector = null;
try
{
// always perform this query - even when not searching by Name!!!
keyVector = FindPublisherByNameQuery.select(name,keyVector,findQualifiers,connection);
}
catch(java.sql.SQLException sqlex)
{
throw new RegistryException(sqlex);
}
return keyVector;
}
}