| /** |
| * |
| * Copyright 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.ws.scout.registry; |
| |
| import java.net.PasswordAuthentication; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.xml.registry.BulkResponse; |
| import javax.xml.registry.BusinessLifeCycleManager; |
| import javax.xml.registry.BusinessQueryManager; |
| import javax.xml.registry.InvalidRequestException; |
| import javax.xml.registry.JAXRException; |
| import javax.xml.registry.LifeCycleManager; |
| import javax.xml.registry.RegistryService; |
| import javax.xml.registry.UnsupportedCapabilityException; |
| import javax.xml.registry.infomodel.Association; |
| import javax.xml.registry.infomodel.ClassificationScheme; |
| import javax.xml.registry.infomodel.Concept; |
| import javax.xml.registry.infomodel.Key; |
| import javax.xml.registry.infomodel.LocalizedString; |
| import javax.xml.registry.infomodel.Organization; |
| import javax.xml.registry.infomodel.RegistryObject; |
| import javax.xml.registry.infomodel.Service; |
| import javax.xml.registry.infomodel.ServiceBinding; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.ws.scout.model.uddi.v2.AssertionStatusItem; |
| import org.apache.ws.scout.model.uddi.v2.AssertionStatusReport; |
| import org.apache.ws.scout.model.uddi.v2.AuthToken; |
| import org.apache.ws.scout.model.uddi.v2.BindingDetail; |
| import org.apache.ws.scout.model.uddi.v2.BindingTemplate; |
| import org.apache.ws.scout.model.uddi.v2.BusinessDetail; |
| import org.apache.ws.scout.model.uddi.v2.BusinessInfo; |
| import org.apache.ws.scout.model.uddi.v2.BusinessInfos; |
| import org.apache.ws.scout.model.uddi.v2.BusinessList; |
| import org.apache.ws.scout.model.uddi.v2.BusinessService; |
| import org.apache.ws.scout.model.uddi.v2.FindQualifiers; |
| import org.apache.ws.scout.model.uddi.v2.KeyedReference; |
| import org.apache.ws.scout.model.uddi.v2.Name; |
| import org.apache.ws.scout.model.uddi.v2.ObjectFactory; |
| import org.apache.ws.scout.model.uddi.v2.PublisherAssertion; |
| import org.apache.ws.scout.model.uddi.v2.PublisherAssertions; |
| import org.apache.ws.scout.model.uddi.v2.RegisteredInfo; |
| import org.apache.ws.scout.model.uddi.v2.ServiceDetail; |
| import org.apache.ws.scout.model.uddi.v2.ServiceInfo; |
| import org.apache.ws.scout.model.uddi.v2.ServiceInfos; |
| import org.apache.ws.scout.model.uddi.v2.ServiceList; |
| import org.apache.ws.scout.model.uddi.v2.TModel; |
| import org.apache.ws.scout.model.uddi.v2.TModelDetail; |
| import org.apache.ws.scout.model.uddi.v2.TModelInfo; |
| import org.apache.ws.scout.model.uddi.v2.TModelInfos; |
| import org.apache.ws.scout.model.uddi.v2.TModelList; |
| import org.apache.ws.scout.registry.infomodel.AssociationImpl; |
| import org.apache.ws.scout.registry.infomodel.ClassificationSchemeImpl; |
| import org.apache.ws.scout.registry.infomodel.ConceptImpl; |
| import org.apache.ws.scout.registry.infomodel.InternationalStringImpl; |
| import org.apache.ws.scout.registry.infomodel.KeyImpl; |
| import org.apache.ws.scout.registry.infomodel.ServiceBindingImpl; |
| import org.apache.ws.scout.registry.infomodel.ServiceImpl; |
| import org.apache.ws.scout.util.EnumerationHelper; |
| import org.apache.ws.scout.util.ScoutJaxrUddiHelper; |
| import org.apache.ws.scout.util.ScoutUddiJaxrHelper; |
| |
| /** |
| * Implements the JAXR BusinessQueryManager Interface |
| * For futher details, look into the JAXR API Javadoc. |
| * |
| * @author <a href="mailto:tcunning@apache.org">Tom Cunningham</a> |
| * @author <a href="mailto:anil@apache.org">Anil Saldhana</a> |
| * @author <a href="mailto:jboynes@apache.org">Jeremy Boynes</a> |
| * @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a> |
| */ |
| public class BusinessQueryManagerImpl implements BusinessQueryManager |
| { |
| private final RegistryServiceImpl registryService; |
| private Log log = LogFactory.getLog(this.getClass()); |
| |
| private static ObjectFactory objectFactory = new ObjectFactory(); |
| |
| public BusinessQueryManagerImpl(RegistryServiceImpl registry) |
| { |
| this.registryService = registry; |
| } |
| |
| public RegistryService getRegistryService() |
| { |
| return registryService; |
| } |
| |
| /** |
| * Finds organizations in the registry that match the specified parameters |
| * |
| * @param findQualifiers |
| * @param namePatterns |
| * @param classifications |
| * @param specifications |
| * @param externalIdentifiers |
| * @param externalLinks |
| * @return BulkResponse |
| * @throws JAXRException |
| */ |
| public BulkResponse findOrganizations(Collection findQualifiers, |
| Collection namePatterns, |
| Collection classifications, |
| Collection specifications, |
| Collection externalIdentifiers, |
| Collection externalLinks) throws JAXRException |
| { |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| try |
| { |
| FindQualifiers juddiFindQualifiers = mapFindQualifiers(findQualifiers); |
| Name[] nameArray = mapNamePatterns(namePatterns); |
| BusinessList result = registry.findBusiness(nameArray, |
| null, |
| ScoutJaxrUddiHelper.getIdentifierBagFromExternalIdentifiers(externalIdentifiers), |
| ScoutJaxrUddiHelper.getCategoryBagFromClassifications(classifications), |
| null, |
| juddiFindQualifiers, |
| registryService.getMaxRows()); |
| |
| BusinessInfo[] bizInfoArr =null; |
| BusinessInfos bizInfos = result.getBusinessInfos(); |
| LinkedHashSet<Organization> orgs = new LinkedHashSet<Organization>(); |
| if(bizInfos != null) |
| { |
| List<BusinessInfo> bizInfoList = bizInfos.getBusinessInfo(); |
| for (BusinessInfo businessInfo : bizInfoList) { |
| //Now get the details on the individual biz |
| BusinessDetail detail = registry.getBusinessDetail(businessInfo.getBusinessKey()); |
| orgs.add(((BusinessLifeCycleManagerImpl)registryService.getLifeCycleManagerImpl()).createOrganization(detail)); |
| } |
| bizInfoArr = new BusinessInfo[bizInfoList.size()]; |
| bizInfoList.toArray(bizInfoArr); |
| } |
| return new BulkResponseImpl(orgs); |
| } catch (RegistryException e) |
| { |
| throw new JAXRException(e); |
| } |
| } |
| |
| public BulkResponse findAssociations(Collection findQualifiers, |
| String sourceObjectId, |
| String targetObjectId, |
| Collection associationTypes) throws JAXRException |
| { |
| //TODO: Currently we just return all the Association objects owned by the caller |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| try |
| { |
| ConnectionImpl con = ((RegistryServiceImpl)getRegistryService()).getConnection(); |
| AuthToken auth = this.getAuthToken(con,registry); |
| PublisherAssertions result = null; |
| try { |
| result = registry.getPublisherAssertions(auth.getAuthInfo()); |
| } catch (RegistryException rve) { |
| String username = getUsernameFromCredentials(con.getCredentials()); |
| if (AuthTokenSingleton.getToken(username) != null) { |
| AuthTokenSingleton.deleteAuthToken(username); |
| } |
| auth = getAuthToken(con, registry); |
| result = registry.getPublisherAssertions(auth.getAuthInfo()); |
| } |
| |
| List<PublisherAssertion> publisherAssertionList = result.getPublisherAssertion(); |
| LinkedHashSet<Association> col = new LinkedHashSet<Association>(); |
| for (PublisherAssertion pas : publisherAssertionList) { |
| String sourceKey = pas.getFromKey(); |
| String targetKey = pas.getToKey(); |
| |
| if ((sourceObjectId==null || sourceObjectId.equals(sourceKey)) |
| && (targetObjectId==null || targetObjectId.equals(targetKey))) { |
| Collection<Key> orgcol = new ArrayList<Key>(); |
| orgcol.add(new KeyImpl(sourceKey)); |
| orgcol.add(new KeyImpl(targetKey)); |
| BulkResponse bl = getRegistryObjects(orgcol, LifeCycleManager.ORGANIZATION); |
| Association asso = ScoutUddiJaxrHelper.getAssociation(bl.getCollection(), |
| registryService.getBusinessLifeCycleManager()); |
| KeyedReference keyr = pas.getKeyedReference(); |
| Concept c = new ConceptImpl(getRegistryService().getBusinessLifeCycleManager()); |
| c.setName(new InternationalStringImpl(keyr.getKeyName())); |
| c.setKey( new KeyImpl(keyr.getTModelKey()) ); |
| c.setValue(keyr.getKeyValue()); |
| asso.setAssociationType(c); |
| col.add(asso); |
| } |
| |
| } |
| return new BulkResponseImpl(col); |
| } catch (RegistryException e) |
| { |
| throw new JAXRException(e); |
| } |
| } |
| |
| public BulkResponse findCallerAssociations(Collection findQualifiers, |
| Boolean confirmedByCaller, |
| Boolean confirmedByOtherParty, |
| Collection associationTypes) throws JAXRException |
| { |
| //TODO: Currently we just return all the Association objects owned by the caller |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| try |
| { |
| ConnectionImpl con = ((RegistryServiceImpl)getRegistryService()).getConnection(); |
| AuthToken auth = this.getAuthToken(con,registry); |
| |
| AssertionStatusReport report = null; |
| String confirm = ""; |
| boolean caller = confirmedByCaller.booleanValue(); |
| boolean other = confirmedByOtherParty.booleanValue(); |
| |
| if(caller && other ) |
| confirm = Constants.COMPLETION_STATUS_COMPLETE; |
| else |
| if(!caller && other ) |
| confirm = Constants.COMPLETION_STATUS_FROMKEY_INCOMPLETE; |
| else |
| if(caller && !other ) |
| confirm = Constants.COMPLETION_STATUS_TOKEY_INCOMPLETE; |
| |
| report = null; |
| try { |
| report = registry.getAssertionStatusReport(auth.getAuthInfo(),confirm); |
| } catch (RegistryException rve) { |
| String username = getUsernameFromCredentials(con.getCredentials()); |
| if (AuthTokenSingleton.getToken(username) != null) { |
| AuthTokenSingleton.deleteAuthToken(username); |
| } |
| auth = getAuthToken(con, registry); |
| report = registry.getAssertionStatusReport(auth.getAuthInfo(),confirm); |
| } |
| |
| List<AssertionStatusItem> assertionStatusItemList = report.getAssertionStatusItem(); |
| LinkedHashSet<Association> col = new LinkedHashSet<Association>(); |
| for (AssertionStatusItem asi : assertionStatusItemList) { |
| String sourceKey = asi.getFromKey(); |
| String targetKey = asi.getToKey(); |
| Collection<Key> orgcol = new ArrayList<Key>(); |
| orgcol.add(new KeyImpl(sourceKey)); |
| orgcol.add(new KeyImpl(targetKey)); |
| BulkResponse bl = getRegistryObjects(orgcol, LifeCycleManager.ORGANIZATION); |
| Association asso = ScoutUddiJaxrHelper.getAssociation(bl.getCollection(), |
| registryService.getBusinessLifeCycleManager()); |
| //Set Confirmation |
| ((AssociationImpl)asso).setConfirmedBySourceOwner(caller); |
| ((AssociationImpl)asso).setConfirmedByTargetOwner(other); |
| |
| if(confirm != Constants.COMPLETION_STATUS_COMPLETE) |
| ((AssociationImpl)asso).setConfirmed(false); |
| |
| Concept c = new ConceptImpl(getRegistryService().getBusinessLifeCycleManager()); |
| KeyedReference keyr = asi.getKeyedReference(); |
| c.setKey(new KeyImpl(keyr.getTModelKey())); |
| c.setName(new InternationalStringImpl(keyr.getKeyName())); |
| c.setValue(keyr.getKeyValue()); |
| asso.setKey(new KeyImpl(keyr.getTModelKey())); //TODO:Validate this |
| asso.setAssociationType(c); |
| col.add(asso); |
| } |
| |
| |
| return new BulkResponseImpl(col); |
| } catch (RegistryException e) |
| { |
| throw new JAXRException(e); |
| } |
| } |
| |
| /** |
| * TODO - need to support the qualifiers |
| * |
| * @param findQualifiers |
| * @param namePatterns |
| * @return ClassificationScheme |
| * @throws JAXRException |
| */ |
| public ClassificationScheme findClassificationSchemeByName(Collection findQualifiers, |
| String namePatterns) throws JAXRException |
| { |
| ClassificationScheme scheme = null; |
| |
| if (namePatterns.indexOf("uddi-org:types") != -1) { |
| |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_TYPES_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("dnb-com:D-U-N-S") != -1) { |
| |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_D_U_N_S_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("uddi-org:iso-ch:3166:1999") != -1) |
| { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_ISO_CH_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("uddi-org:iso-ch:3166-1999") != -1) |
| { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_ISO_CH_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("iso-ch:3166:1999") != -1) |
| { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_ISO_CH_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("iso-ch:3166-1999") != -1) |
| { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_ISO_CH_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("unspsc-org:unspsc") != -1) { |
| |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| } |
| else if (namePatterns.indexOf("ntis-gov:naics") != -1) { |
| |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| scheme.setKey(new KeyImpl(Constants.TMODEL_NAICS_TMODEL_KEY)); |
| } |
| else |
| { //TODO:Before going to the registry, check if it a predefined Enumeration |
| |
| /* |
| * predefined Enumerations |
| */ |
| |
| if ("AssociationType".equals(namePatterns)) { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| |
| addChildConcept((ClassificationSchemeImpl)scheme, "RelatedTo"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "HasChild"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "HasMember"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "HasParent"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ExternallyLinks"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Contains"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "EquivalentTo"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Extends"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Implements"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "InstanceOf"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Supersedes"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Uses"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Replaces"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ResponsibleFor"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "SubmitterOf"); |
| } |
| else if ("ObjectType".equals(namePatterns)) { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| |
| addChildConcept((ClassificationSchemeImpl)scheme, "CPP"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "CPA"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Process"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "WSDL"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Association"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "AuditableEvent"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Classification"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Concept"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ExternalIdentifier"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ExternalLink"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ExtrinsicObject"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Organization"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Package"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Service"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "ServiceBinding"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "User"); |
| } |
| else if ("PhoneType".equals(namePatterns)) { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| |
| addChildConcept((ClassificationSchemeImpl)scheme, "OfficePhone"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "HomePhone"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "MobilePhone"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Beeper"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "FAX"); |
| } |
| else if ("URLType".equals(namePatterns)) { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| |
| addChildConcept((ClassificationSchemeImpl)scheme, "HTTP"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "HTTPS"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "SMTP"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "PHONE"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "FAX"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "OTHER"); |
| } |
| else if ("PostalAddressAttributes".equals(namePatterns)) { |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| |
| scheme.setName(new InternationalStringImpl(namePatterns)); |
| |
| scheme.setKey(new KeyImpl(Constants.TMODEL_UNSPSC_TMODEL_KEY)); |
| |
| addChildConcept((ClassificationSchemeImpl)scheme, "StreetNumber"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Street"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "City"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "State"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "PostalCode"); |
| addChildConcept((ClassificationSchemeImpl)scheme, "Country"); |
| } |
| else { |
| |
| //Lets ask the uddi registry if it has the TModels |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| FindQualifiers juddiFindQualifiers = mapFindQualifiers(findQualifiers); |
| try |
| { |
| //We are looking for one exact match, so getting upto 3 records is fine |
| TModelList list = registry.findTModel(namePatterns, null, null, juddiFindQualifiers, 3); |
| if (list != null) { |
| TModelInfos infos = list.getTModelInfos(); |
| if (infos != null) { |
| List<TModelInfo> tmodelInfoList = infos.getTModelInfo(); |
| if (tmodelInfoList.size() > 1) { |
| throw new InvalidRequestException("Multiple matches found:" + tmodelInfoList.size()); |
| } |
| if (tmodelInfoList.size() ==1) { |
| TModelInfo info = tmodelInfoList.get(0); |
| scheme = new ClassificationSchemeImpl(registryService.getLifeCycleManagerImpl()); |
| scheme.setName(new InternationalStringImpl(info.getName().getValue())); |
| scheme.setKey(new KeyImpl(info.getTModelKey())); |
| } |
| } |
| } |
| |
| } catch (RegistryException e) |
| { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| } |
| return scheme; |
| } |
| |
| /** |
| * Creates a new Concept, associates w/ parent scheme, and then |
| * adds as decendent. |
| * @param scheme |
| * @param name |
| * @throws JAXRException |
| */ |
| private void addChildConcept(ClassificationSchemeImpl scheme, String name) |
| throws JAXRException { |
| Concept c = new ConceptImpl(registryService.getLifeCycleManagerImpl()); |
| |
| c.setName(new InternationalStringImpl(name)); |
| c.setValue(name); |
| ((ConceptImpl)c).setScheme((ClassificationSchemeImpl)scheme); |
| |
| scheme.addChildConcept(c); |
| } |
| |
| public BulkResponse findClassificationSchemes(Collection findQualifiers, |
| Collection namePatterns, |
| Collection classifications, |
| Collection externalLinks) throws JAXRException |
| { |
| //TODO: Handle this better |
| LinkedHashSet<ClassificationScheme> col = new LinkedHashSet<ClassificationScheme>(); |
| Iterator iter = namePatterns.iterator(); |
| String name = ""; |
| while(iter.hasNext()) |
| { |
| name = (String)iter.next(); |
| break; |
| } |
| |
| ClassificationScheme classificationScheme = findClassificationSchemeByName(findQualifiers,name); |
| if (classificationScheme!=null) { |
| col.add(classificationScheme); |
| } |
| return new BulkResponseImpl(col); |
| } |
| |
| public Concept findConceptByPath(String path) throws JAXRException |
| { |
| //We will store the enumerations datastructure in the util package |
| /** |
| * I am not clear about how this association type enumerations |
| * are to be implemented. |
| */ |
| return EnumerationHelper.getConceptByPath(path); |
| } |
| |
| public BulkResponse findConcepts(Collection findQualifiers, |
| Collection namePatterns, |
| Collection classifications, |
| Collection externalIdentifiers, |
| Collection externalLinks) throws JAXRException |
| { |
| LinkedHashSet<Concept> col = new LinkedHashSet<Concept>(); |
| |
| //Lets ask the uddi registry if it has the TModels |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| FindQualifiers juddiFindQualifiers = mapFindQualifiers(findQualifiers); |
| Iterator iter = null; |
| if (namePatterns != null) iter = namePatterns.iterator(); |
| while (iter.hasNext()) |
| { |
| String namestr = (String) iter.next(); |
| try |
| { |
| TModelList list = registry.findTModel(namestr, |
| ScoutJaxrUddiHelper.getCategoryBagFromClassifications(classifications), |
| ScoutJaxrUddiHelper.getIdentifierBagFromExternalIdentifiers(externalIdentifiers), |
| juddiFindQualifiers, 10); |
| |
| if (list != null && list.getTModelInfos()!=null) { |
| List<TModelInfo> tmodelInfoList = list.getTModelInfos().getTModelInfo(); |
| if (tmodelInfoList!=null) { |
| for (TModelInfo info: tmodelInfoList) { |
| col.add(ScoutUddiJaxrHelper.getConcept(info, this.registryService.getBusinessLifeCycleManager())); |
| } |
| } |
| } |
| } catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| |
| return new BulkResponseImpl(col); |
| } |
| |
| public BulkResponse findRegistryPackages(Collection findQualifiers, |
| Collection namePatterns, |
| Collection classifications, |
| Collection externalLinks) throws JAXRException |
| { |
| throw new UnsupportedCapabilityException(); |
| } |
| |
| public BulkResponse findServiceBindings(Key serviceKey, |
| Collection findQualifiers, |
| Collection classifications, |
| Collection specifications) throws JAXRException |
| { |
| BulkResponseImpl blkRes = new BulkResponseImpl(); |
| |
| IRegistry iRegistry = (IRegistry) registryService.getRegistry(); |
| FindQualifiers juddiFindQualifiers = mapFindQualifiers(findQualifiers); |
| |
| try |
| { |
| |
| BindingDetail bindingDetail = iRegistry.findBinding(serviceKey.getId(), |
| ScoutJaxrUddiHelper.getCategoryBagFromClassifications(classifications), |
| ScoutJaxrUddiHelper.getTModelBagFromSpecifications(specifications), |
| juddiFindQualifiers,registryService.getMaxRows()); |
| |
| /* |
| * now convert from jUDDI ServiceInfo objects to JAXR Services |
| */ |
| if (bindingDetail != null) { |
| |
| List<BindingTemplate> bindingTemplateList = bindingDetail.getBindingTemplate(); |
| BindingTemplate[] bindarr = new BindingTemplate[bindingTemplateList.size()]; |
| bindingTemplateList.toArray(bindarr); |
| |
| LinkedHashSet<ServiceBinding> col = new LinkedHashSet<ServiceBinding>(); |
| |
| for (int i=0; bindarr != null && i < bindarr.length; i++) { |
| BindingTemplate si = bindarr[i]; |
| ServiceBinding sb = ScoutUddiJaxrHelper.getServiceBinding(si, |
| registryService.getBusinessLifeCycleManager()); |
| col.add(sb); |
| //Fill the Service object by making a call to registry |
| Service s = (Service)getRegistryObject(serviceKey.getId(), LifeCycleManager.SERVICE); |
| ((ServiceBindingImpl)sb).setService(s); |
| } |
| |
| blkRes.setCollection(col); |
| } |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| |
| return blkRes; |
| } |
| |
| |
| /** |
| * Finds all Service objects that match all of the criteria specified by |
| * the parameters of this call. This is a logical AND operation between |
| * all non-null parameters |
| * |
| * TODO - support findQualifiers, classifications and specifications |
| * |
| * @param orgKey |
| * @param findQualifiers |
| * @param namePatterns |
| * @param classifications |
| * @param specificationa |
| * @return BulkResponse |
| * @throws JAXRException |
| */ |
| public BulkResponse findServices(Key orgKey, Collection findQualifiers, |
| Collection namePatterns, |
| Collection classifications, |
| Collection specificationa) throws JAXRException |
| { |
| BulkResponseImpl blkRes = new BulkResponseImpl(); |
| |
| IRegistry iRegistry = (IRegistry) registryService.getRegistry(); |
| FindQualifiers juddiFindQualifiers = mapFindQualifiers(findQualifiers); |
| Name[] juddiNames = mapNamePatterns(namePatterns); |
| |
| try |
| { |
| /* |
| * hit the registry. The key is not required for UDDI2 |
| */ |
| |
| String id = null; |
| |
| if (orgKey != null) { |
| id = orgKey.getId(); |
| } |
| |
| ServiceList serviceList = iRegistry.findService(id, |
| juddiNames, |
| ScoutJaxrUddiHelper.getCategoryBagFromClassifications(classifications), |
| null, |
| juddiFindQualifiers, registryService.getMaxRows()); |
| |
| /* |
| * now convert from jUDDI ServiceInfo objects to JAXR Services |
| */ |
| if (serviceList != null) { |
| |
| ServiceInfos serviceInfos = serviceList.getServiceInfos(); |
| LinkedHashSet<Service> col = new LinkedHashSet<Service>(); |
| |
| if(serviceInfos != null && serviceInfos.getServiceInfo()!=null) { |
| for (ServiceInfo si : serviceInfos.getServiceInfo()) { |
| Service srv = (Service) getRegistryObject(si.getServiceKey(), LifeCycleManager.SERVICE); |
| col.add(srv); |
| } |
| |
| } |
| blkRes.setCollection(col); |
| } |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| |
| return blkRes; |
| } |
| |
| public RegistryObject getRegistryObject(String id) throws JAXRException |
| { |
| throw new UnsupportedCapabilityException(); |
| } |
| |
| public RegistryObject getRegistryObject(String id, String objectType) throws JAXRException |
| { |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| BusinessLifeCycleManager lcm = registryService.getBusinessLifeCycleManager(); |
| |
| if (LifeCycleManager.CLASSIFICATION_SCHEME.equalsIgnoreCase(objectType)) { |
| |
| try { |
| |
| TModelDetail tmodeldetail = registry.getTModelDetail(id); |
| Concept c = ScoutUddiJaxrHelper.getConcept(tmodeldetail, lcm); |
| |
| /* |
| * now turn into a concrete ClassificationScheme |
| */ |
| |
| ClassificationScheme scheme = new ClassificationSchemeImpl(lcm); |
| |
| scheme.setName(c.getName()); |
| scheme.setDescription(c.getDescription()); |
| scheme.setKey(c.getKey()); |
| |
| return scheme; |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| else if (LifeCycleManager.ORGANIZATION.equalsIgnoreCase(objectType)) { |
| try |
| { |
| BusinessDetail orgdetail = registry.getBusinessDetail(id); |
| return ScoutUddiJaxrHelper.getOrganization(orgdetail, lcm); |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| |
| } |
| else if (LifeCycleManager.CONCEPT.equalsIgnoreCase(objectType)) { |
| |
| try |
| { |
| TModelDetail tmodeldetail = registry.getTModelDetail(id); |
| return ScoutUddiJaxrHelper.getConcept(tmodeldetail, lcm); |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| else if (LifeCycleManager.SERVICE.equalsIgnoreCase(objectType)) { |
| |
| try { |
| ServiceDetail sd = registry.getServiceDetail(id); |
| if (sd != null && sd.getBusinessService()!=null) { |
| for (BusinessService businessService : sd.getBusinessService()) { |
| Service service = getServiceFromBusinessService(businessService, lcm); |
| return service; |
| } |
| } |
| } |
| catch (RegistryException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Helper routine to take a jUDDI business service and turn into a useful |
| * Service. Needs to go back to the registry to get the organization to |
| * properly hydrate the Service |
| * |
| * @param bs BusinessService object to turn in to a Service |
| * @param lcm manager to use |
| * @return new Service object |
| * @throws JAXRException |
| */ |
| protected Service getServiceFromBusinessService(BusinessService bs, LifeCycleManager lcm) |
| throws JAXRException { |
| |
| ServiceImpl service = (ServiceImpl) ScoutUddiJaxrHelper.getService(bs, lcm); |
| service.setSubmittingOrganizationKey(bs.getBusinessKey()); |
| |
| return service; |
| } |
| |
| /** |
| * Gets the RegistryObjects owned by the caller. The objects |
| * are returned as their concrete type (e.g. Organization, User etc.) |
| * |
| * TODO - need to figure out what the set are. This is just to get some |
| * basic functionality |
| * |
| * @return BulkResponse |
| * @throws JAXRException |
| */ |
| public BulkResponse getRegistryObjects() throws JAXRException |
| { |
| String types[] = { |
| LifeCycleManager.ORGANIZATION, |
| LifeCycleManager.SERVICE}; |
| |
| LinkedHashSet<Object> c = new LinkedHashSet<Object>(); |
| |
| for (int i = 0; i < types.length; i++) { |
| try { |
| BulkResponse bk = getRegistryObjects(types[i]); |
| |
| if (bk.getCollection() != null) { |
| c.addAll(bk.getCollection()); |
| } |
| } catch(JAXRException e) { |
| log.debug("ignore - just a problem with that type? " + e.getMessage(), e); |
| } |
| } |
| |
| return new BulkResponseImpl(c); |
| } |
| |
| public BulkResponse getRegistryObjects(Collection objectKeys) throws JAXRException |
| { |
| throw new UnsupportedCapabilityException(); |
| } |
| |
| public BulkResponse getRegistryObjects(Collection objectKeys, String objectType) throws JAXRException |
| { |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| //Convert into a vector of strings |
| String[] keys = new String[objectKeys.size()]; |
| int currLoc = 0; |
| for (Key key : (Collection<Key>) objectKeys) { |
| keys[currLoc] = key.getId(); |
| currLoc++; |
| } |
| LinkedHashSet<RegistryObject> col = new LinkedHashSet<RegistryObject>(); |
| LifeCycleManager lcm = registryService.getLifeCycleManagerImpl(); |
| |
| if (LifeCycleManager.CLASSIFICATION_SCHEME.equalsIgnoreCase(objectType)) |
| { |
| try |
| { |
| TModelDetail tmodeldetail = registry.getTModelDetail(keys); |
| List<TModel> tmodelList = tmodeldetail.getTModel(); |
| |
| for (TModel tModel: tmodelList) |
| { |
| col.add(ScoutUddiJaxrHelper.getConcept(tModel, lcm)); |
| } |
| |
| } catch (RegistryException e) |
| { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| else if (LifeCycleManager.ORGANIZATION.equalsIgnoreCase(objectType)) |
| { |
| ConnectionImpl con = ((RegistryServiceImpl)getRegistryService()).getConnection(); |
| AuthToken auth = this.getAuthToken(con,registry); |
| |
| try |
| { |
| RegisteredInfo ri = null; |
| try { |
| ri = registry.getRegisteredInfo(auth.getAuthInfo()); |
| } catch (RegistryException rve) { |
| String username = getUsernameFromCredentials(con.getCredentials()); |
| if (AuthTokenSingleton.getToken(username) != null) { |
| AuthTokenSingleton.deleteAuthToken(username); |
| } |
| auth = getAuthToken(con, registry); |
| ri = registry.getRegisteredInfo(auth.getAuthInfo()); |
| } |
| |
| if (ri != null) { |
| for (String key:keys) { |
| BusinessDetail detail = registry.getBusinessDetail(key); |
| col.add(((BusinessLifeCycleManagerImpl)registryService.getLifeCycleManagerImpl()).createOrganization(detail)); |
| } |
| |
| } |
| } catch (RegistryException e) { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| else if (LifeCycleManager.CONCEPT.equalsIgnoreCase(objectType)) |
| { |
| try { |
| TModelDetail tmodeldetail = registry.getTModelDetail(keys); |
| List<TModel> tmodelList = tmodeldetail.getTModel(); |
| |
| for (TModel tmodel: tmodelList) |
| { |
| col.add(ScoutUddiJaxrHelper.getConcept(tmodel, lcm)); |
| } |
| |
| } |
| catch (RegistryException e) |
| { |
| throw new JAXRException(e.getLocalizedMessage()); |
| } |
| } |
| else if (LifeCycleManager.SERVICE.equalsIgnoreCase(objectType)) { |
| |
| try { |
| ServiceDetail serviceDetail = registry.getServiceDetail(keys); |
| |
| if (serviceDetail != null) { |
| List<BusinessService> bizServiceList = serviceDetail.getBusinessService(); |
| |
| for (BusinessService businessService: bizServiceList) { |
| |
| Service service = getServiceFromBusinessService(businessService, lcm); |
| |
| col.add(service); |
| } |
| } |
| } |
| catch (RegistryException e) { |
| throw new JAXRException(e); |
| } |
| } |
| else { |
| throw new JAXRException("Unsupported type " + objectType + |
| " for getRegistryObjects() in Apache Scout"); |
| } |
| |
| return new BulkResponseImpl(col); |
| |
| } |
| |
| public BulkResponse getRegistryObjects(String id) throws JAXRException |
| { |
| if (LifeCycleManager.ORGANIZATION.equalsIgnoreCase(id)) { |
| IRegistry registry = (IRegistry) registryService.getRegistry(); |
| ConnectionImpl con = ((RegistryServiceImpl)getRegistryService()).getConnection(); |
| AuthToken auth = this.getAuthToken(con,registry); |
| LinkedHashSet<Organization> orgs = null; |
| try |
| { |
| RegisteredInfo ri = null; |
| try { |
| ri = registry.getRegisteredInfo(auth.getAuthInfo()); |
| } catch (RegistryException rve) { |
| String username = getUsernameFromCredentials(con.getCredentials()); |
| if (AuthTokenSingleton.getToken(username) != null) { |
| AuthTokenSingleton.deleteAuthToken(username); |
| } |
| auth = getAuthToken(con, registry); |
| ri = registry.getRegisteredInfo(auth.getAuthInfo()); |
| } |
| |
| if (ri != null && ri.getBusinessInfos()!=null) { |
| List<BusinessInfo> bizInfoList = ri.getBusinessInfos().getBusinessInfo(); |
| orgs = new LinkedHashSet<Organization>(); |
| for (BusinessInfo businessInfo : bizInfoList) { |
| BusinessDetail detail = registry.getBusinessDetail(businessInfo.getBusinessKey()); |
| orgs.add(((BusinessLifeCycleManagerImpl)registryService.getLifeCycleManagerImpl()).createOrganization(detail)); |
| } |
| } |
| |
| } catch (RegistryException re) { |
| throw new JAXRException(re); |
| } |
| return new BulkResponseImpl(orgs); |
| } |
| else if (LifeCycleManager.SERVICE.equalsIgnoreCase(id)) { |
| List<String> a = new ArrayList<String>(); |
| a.add("%"); |
| |
| BulkResponse br = this.findServices(null,null, a, null, null); |
| |
| return br; |
| } |
| else |
| { |
| throw new JAXRException("Unsupported type for getRegistryObjects() :" + id); |
| } |
| |
| } |
| |
| static FindQualifiers mapFindQualifiers(Collection jaxrQualifiers) throws UnsupportedCapabilityException |
| { |
| if (jaxrQualifiers == null) |
| { |
| return null; |
| } |
| FindQualifiers result = objectFactory.createFindQualifiers(); |
| for (Iterator i = jaxrQualifiers.iterator(); i.hasNext();) |
| { |
| String jaxrQualifier = (String) i.next(); |
| String juddiQualifier = jaxrQualifier; |
| if (juddiQualifier == null) |
| { |
| throw new UnsupportedCapabilityException("jUDDI does not support FindQualifer: " + jaxrQualifier); |
| } |
| result.getFindQualifier().add(juddiQualifier); |
| } |
| return result; |
| } |
| |
| static Name[] mapNamePatterns(Collection namePatterns) |
| throws JAXRException |
| { |
| if (namePatterns == null) |
| return null; |
| Name[] result = new Name[namePatterns.size()]; |
| int currLoc = 0; |
| for (Iterator i = namePatterns.iterator(); i.hasNext();) |
| { |
| Object obj = i.next(); |
| Name name = objectFactory.createName(); |
| if (obj instanceof String) { |
| name.setValue((String)obj); |
| } else if (obj instanceof LocalizedString) { |
| LocalizedString ls = (LocalizedString)obj; |
| name.setValue(ls.getValue()); |
| name.setLang(ls.getLocale().getLanguage()); |
| } |
| result[currLoc] = name; |
| currLoc++; |
| } |
| return result; |
| } |
| |
| /** |
| * Get the Auth Token from the registry |
| * |
| * @param connection |
| * @param ireg |
| * @return auth token |
| * @throws JAXRException |
| */ |
| private AuthToken getAuthToken(ConnectionImpl connection, IRegistry ireg) |
| throws JAXRException { |
| Set creds = connection.getCredentials(); |
| Iterator it = creds.iterator(); |
| String username = "", pwd = ""; |
| while (it.hasNext()) { |
| PasswordAuthentication pass = (PasswordAuthentication) it.next(); |
| username = pass.getUserName(); |
| pwd = new String(pass.getPassword()); |
| } |
| |
| if (AuthTokenSingleton.getToken(username) != null) { |
| return (AuthToken) AuthTokenSingleton.getToken(username); |
| } |
| |
| AuthToken token = null; |
| try { |
| token = ireg.getAuthToken(username, pwd); |
| } |
| catch (Exception e) { |
| throw new JAXRException(e); |
| } |
| AuthTokenSingleton.addAuthToken(username, token); |
| |
| return token; |
| } |
| |
| private String getUsernameFromCredentials(Set credentials) { |
| String username = "", pwd = ""; |
| |
| if (credentials != null) { |
| Iterator it = credentials.iterator(); |
| while (it.hasNext()) { |
| PasswordAuthentication pass = (PasswordAuthentication) it.next(); |
| username = pass.getUserName(); |
| } |
| } |
| return username; |
| } |
| |
| } |