| /* | |
| * Copyright 2001-2008 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.mapping; | |
| import java.math.BigInteger; | |
| import java.util.GregorianCalendar; | |
| import javax.xml.datatype.DatatypeConfigurationException; | |
| import javax.xml.datatype.DatatypeFactory; | |
| import org.w3._2000._09.xmldsig_.X509IssuerSerialType; | |
| import java.io.ByteArrayInputStream; | |
| import java.io.StringReader; | |
| import java.io.UnsupportedEncodingException; | |
| import java.util.ArrayList; | |
| import java.util.Collections; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.logging.Level; | |
| import java.util.logging.Logger; | |
| import javax.persistence.EntityManager; | |
| import javax.xml.bind.JAXB; | |
| import javax.xml.bind.JAXBElement; | |
| import javax.xml.bind.JAXBException; | |
| import javax.xml.namespace.QName; | |
| import javax.xml.parsers.DocumentBuilder; | |
| import javax.xml.parsers.DocumentBuilderFactory; | |
| import org.apache.commons.configuration.ConfigurationException; | |
| import org.apache.commons.logging.Log; | |
| import org.apache.commons.logging.LogFactory; | |
| import org.apache.juddi.config.AppConfig; | |
| import org.apache.juddi.config.Property; | |
| import org.apache.juddi.jaxb.JAXBMarshaller; | |
| import org.apache.juddi.model.CanonicalizationMethod; | |
| import org.apache.juddi.model.ControlMessage; | |
| import org.apache.juddi.model.Edge; | |
| import org.apache.juddi.model.EdgeReceiverAlternate; | |
| import org.apache.juddi.model.KeyInfo; | |
| import org.apache.juddi.model.OverviewDoc; | |
| import org.apache.juddi.model.Reference; | |
| import org.apache.juddi.model.SignatureTransform; | |
| import org.apache.juddi.model.SignatureValue; | |
| import org.apache.juddi.model.SignedInfo; | |
| import org.apache.juddi.model.UddiEntity; | |
| import org.apache.juddi.model.KeyDataValue; | |
| import org.apache.juddi.model.Node; | |
| import org.apache.juddi.model.ReplicationConfiguration; | |
| import org.apache.juddi.model.ReplicationConfigurationNode; | |
| import org.apache.juddi.model.Signature; | |
| import org.apache.juddi.model.SignatureTransformDataValue; | |
| import org.apache.juddi.subscription.TypeConvertor; | |
| import org.apache.juddi.v3.client.cryptor.XmlUtils; | |
| import org.apache.juddi.v3.error.ErrorMessage; | |
| import org.apache.juddi.v3.error.FatalErrorException; | |
| import org.uddi.api_v3.BusinessEntity; | |
| import org.uddi.api_v3.CompletionStatus; | |
| import org.uddi.api_v3.Contact; | |
| import org.uddi.api_v3.Contacts; | |
| import org.uddi.api_v3.OperationalInfo; | |
| import org.uddi.api_v3.PersonName; | |
| import org.uddi.repl_v3.ChangeRecord; | |
| import org.uddi.repl_v3.ChangeRecordIDType; | |
| import org.uddi.repl_v3.CommunicationGraph; | |
| import org.uddi.repl_v3.Operator; | |
| import org.uddi.repl_v3.OperatorStatusType; | |
| import org.uddi.sub_v3.SubscriptionFilter; | |
| import org.uddi.v3_service.DispositionReportFaultMessage; | |
| import org.w3._2000._09.xmldsig_.CanonicalizationMethodType; | |
| import org.w3._2000._09.xmldsig_.DSAKeyValueType; | |
| import org.w3._2000._09.xmldsig_.DigestMethodType; | |
| import org.w3._2000._09.xmldsig_.KeyInfoType; | |
| import org.w3._2000._09.xmldsig_.KeyValueType; | |
| import org.w3._2000._09.xmldsig_.PGPDataType; | |
| import org.w3._2000._09.xmldsig_.RSAKeyValueType; | |
| import org.w3._2000._09.xmldsig_.ReferenceType; | |
| import org.w3._2000._09.xmldsig_.RetrievalMethodType; | |
| import org.w3._2000._09.xmldsig_.SPKIDataType; | |
| import org.w3._2000._09.xmldsig_.SignatureMethodType; | |
| import org.w3._2000._09.xmldsig_.SignatureType; | |
| import org.w3._2000._09.xmldsig_.SignatureValueType; | |
| import org.w3._2000._09.xmldsig_.SignedInfoType; | |
| import org.w3._2000._09.xmldsig_.TransformType; | |
| import org.w3._2000._09.xmldsig_.TransformsType; | |
| import org.w3._2000._09.xmldsig_.X509DataType; | |
| import org.w3c.dom.Document; | |
| import org.w3c.dom.Element; | |
| /** | |
| * @author <a href="mailto:jfaath@apache.org">Jeff Faath</a> | |
| * @author <a href="mailto:kstam@apache.org">Kurt T Stam</a> | |
| */ | |
| public class MappingModelToApi { | |
| private static Log logger = LogFactory.getLog(MappingModelToApi.class); | |
| public static void mapPublisher(org.apache.juddi.model.Publisher modelPublisher, | |
| org.apache.juddi.api_v3.Publisher apiPublisher) | |
| throws DispositionReportFaultMessage { | |
| apiPublisher.setAuthorizedName(modelPublisher.getAuthorizedName()); | |
| apiPublisher.setPublisherName(modelPublisher.getPublisherName()); | |
| apiPublisher.setEmailAddress(modelPublisher.getEmailAddress()); | |
| apiPublisher.setIsAdmin(modelPublisher.getIsAdmin()); | |
| apiPublisher.setIsEnabled(modelPublisher.getIsEnabled()); | |
| apiPublisher.setMaxBindingsPerService(modelPublisher.getMaxBindingsPerService()); | |
| apiPublisher.setMaxBusinesses(modelPublisher.getMaxBusinesses()); | |
| apiPublisher.setMaxServicePerBusiness(modelPublisher.getMaxServicesPerBusiness()); | |
| apiPublisher.setMaxTModels(modelPublisher.getMaxTmodels()); | |
| mapSignature(modelPublisher.getSignatures(), apiPublisher.getSignature()); | |
| } | |
| public static void mapBusinessEntity(org.apache.juddi.model.BusinessEntity modelBusinessEntity, | |
| org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| throws DispositionReportFaultMessage { | |
| apiBusinessEntity.setBusinessKey(modelBusinessEntity.getEntityKey()); | |
| mapBusinessNames(modelBusinessEntity.getBusinessNames(), apiBusinessEntity.getName()); | |
| mapBusinessDescriptions(modelBusinessEntity.getBusinessDescrs(), apiBusinessEntity.getDescription()); | |
| mapDiscoveryUrls(modelBusinessEntity.getDiscoveryUrls(), apiBusinessEntity.getDiscoveryURLs(), apiBusinessEntity); | |
| mapContacts(modelBusinessEntity.getContacts(), apiBusinessEntity.getContacts(), apiBusinessEntity); | |
| mapBusinessIdentifiers(modelBusinessEntity.getBusinessIdentifiers(), apiBusinessEntity.getIdentifierBag(), apiBusinessEntity); | |
| apiBusinessEntity.setCategoryBag(mapCategoryBag(modelBusinessEntity.getCategoryBag(), apiBusinessEntity.getCategoryBag())); | |
| mapBusinessServices(modelBusinessEntity.getBusinessServices(), modelBusinessEntity.getServiceProjections(), apiBusinessEntity.getBusinessServices(), apiBusinessEntity); | |
| mapSignature(modelBusinessEntity.getSignatures(), apiBusinessEntity.getSignature()); | |
| } | |
| public static void mapSignature(List<org.apache.juddi.model.Signature> signatureList, | |
| List<org.w3._2000._09.xmldsig_.SignatureType> apiSignatureList) | |
| throws DispositionReportFaultMessage { | |
| apiSignatureList.clear(); | |
| for (org.apache.juddi.model.Signature modelSig : signatureList) { | |
| SignatureType apiSignature = new SignatureType(); | |
| apiSignature.setId(modelSig.getXmlID()); | |
| SignedInfo modelSignedInfo = modelSig.getSignedInfo(); | |
| SignedInfoType apiSignedInfoType = new SignedInfoType(); | |
| apiSignature.setSignedInfo(apiSignedInfoType); | |
| // Canonicalization method | |
| CanonicalizationMethod modelCanonMethod = modelSignedInfo.getCanonicalizationMethod(); | |
| CanonicalizationMethodType apiCanonMethod = new CanonicalizationMethodType(); | |
| apiCanonMethod.setAlgorithm(modelCanonMethod.getAlgorithm()); | |
| apiSignedInfoType.setCanonicalizationMethod(apiCanonMethod); | |
| // Signature Method | |
| String sigAlg = modelSignedInfo.getSignatureMethod().getAlgorithm(); | |
| SignatureMethodType apiSigMethod = new SignatureMethodType(); | |
| apiSigMethod.setAlgorithm(sigAlg); | |
| apiSignedInfoType.setSignatureMethod(apiSigMethod); | |
| // References | |
| List<Reference> modelReferenceList = modelSignedInfo.getReference(); | |
| List<ReferenceType> apiReferenceList = apiSignedInfoType.getReference(); | |
| for (Reference modelRef : modelReferenceList) { | |
| ReferenceType apiRef = new ReferenceType(); | |
| String refUri = modelRef.getUri(); | |
| if (refUri == null) { | |
| refUri = ""; | |
| } | |
| apiRef.setURI(refUri); | |
| List<SignatureTransform> modelSigTransformList = modelRef.getTransforms(); | |
| TransformsType apiTransformsType = apiRef.getTransforms(); | |
| if (apiTransformsType == null) { | |
| apiTransformsType = new TransformsType(); | |
| apiRef.setTransforms(apiTransformsType); | |
| } | |
| List<TransformType> apiTransformList = apiTransformsType.getTransform(); | |
| for (SignatureTransform modelSigTransform : modelSigTransformList) { | |
| String modelTransformAlgStr = modelSigTransform.getTransform(); | |
| TransformType apiTransform = new TransformType(); | |
| apiTransform.setAlgorithm(modelTransformAlgStr); | |
| List<SignatureTransformDataValue> sigTransformSDVList = modelSigTransform.getSignatureTransformDataValue(); | |
| for (SignatureTransformDataValue sigTransformSDV : sigTransformSDVList) { | |
| String type = sigTransformSDV.getContentType(); | |
| byte[] xformBytes = sigTransformSDV.getContentBytes(); | |
| Object transformObject = convertDataToTransformContent(type, xformBytes); | |
| apiTransform.getContent().add(transformObject); | |
| } | |
| apiTransformList.add(apiTransform); | |
| } | |
| String digestMethodStr = modelRef.getDigestMethod(); | |
| byte[] digestValBytes = modelRef.getDigestValue(); | |
| DigestMethodType apiDigestMethod = new DigestMethodType(); | |
| apiDigestMethod.setAlgorithm(digestMethodStr); | |
| apiRef.setDigestMethod(apiDigestMethod); | |
| apiRef.setDigestValue(digestValBytes); | |
| apiReferenceList.add(apiRef); | |
| } | |
| // Signature Value | |
| SignatureValueType apiSignatureValue = new SignatureValueType(); | |
| SignatureValue modelSigValue = modelSig.getSignatureValue(); | |
| apiSignatureValue.setId(modelSigValue.getXmlID()); | |
| apiSignatureValue.setValue(modelSigValue.getValue()); | |
| apiSignature.setSignatureValue(apiSignatureValue); | |
| KeyInfoType apiKeyInfo = new KeyInfoType(); | |
| KeyInfo modelKeyInfo = modelSig.getKeyInfo(); | |
| apiKeyInfo.setId(modelKeyInfo.getXmlID()); | |
| List<KeyDataValue> modelKeyDataValueList = modelKeyInfo.getKeyDataValue(); | |
| List<Object> apiX509KeyInfoList = apiKeyInfo.getContent(); | |
| mapModelKeyDataValue(modelKeyDataValueList, apiX509KeyInfoList); | |
| apiSignature.setKeyInfo(apiKeyInfo); | |
| apiSignatureList.add(apiSignature); | |
| } | |
| } | |
| private static void mapModelKeyDataValue(List<KeyDataValue> modelKeyDataValueList, List<Object> parentKeyDataList) { | |
| for (KeyDataValue modelKeyDataValue : modelKeyDataValueList) { | |
| String tagName = modelKeyDataValue.getKeyDataName(); | |
| String dataType = modelKeyDataValue.getKeyDataType(); | |
| byte[] contentBytes = modelKeyDataValue.getKeyDataValueBytes(); | |
| String contentStr = modelKeyDataValue.getKeyDataValueString(); | |
| Object contents = contentBytes != null ? contentBytes : contentStr; | |
| if (contents == null) { | |
| List<Object> childKeyDataList = new ArrayList<Object>(); | |
| if (dataType.equals(X509DataType.class.getSimpleName())) { | |
| X509DataType x509DataType = new X509DataType(); | |
| mapModelKeyDataValue(modelKeyDataValue.getKeyDataValueList(), childKeyDataList); | |
| x509DataType.getX509IssuerSerialOrX509SKIOrX509SubjectName().addAll(childKeyDataList); | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), X509DataType.class, x509DataType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else if (dataType.equals(RetrievalMethodType.class.getSimpleName())) { | |
| RetrievalMethodType retrievalMethodType = new RetrievalMethodType(); | |
| TransformsType transformsType = new TransformsType(); | |
| for (KeyDataValue retrievalMethodKDV : modelKeyDataValue.getKeyDataValueList()) { | |
| if (retrievalMethodKDV.getKeyDataName().equals("Transform")) { | |
| TransformType tType = new TransformType(); | |
| tType.setAlgorithm(retrievalMethodKDV.getKeyDataValueString()); | |
| for (KeyDataValue transformContentKDV : retrievalMethodKDV.getKeyDataValueList()) { | |
| String type = transformContentKDV.getKeyDataType(); | |
| byte[] xformBytes = transformContentKDV.getKeyDataValueBytes(); | |
| Object transformObject = convertDataToTransformContent(type, xformBytes); | |
| tType.getContent().add(transformObject); | |
| } | |
| transformsType.getTransform().add(tType); | |
| } else if (retrievalMethodKDV.getKeyDataName().equals("Type")) { | |
| retrievalMethodType.setType(retrievalMethodKDV.getKeyDataValueString()); | |
| } else if (retrievalMethodKDV.getKeyDataName().equals("URI")) { | |
| retrievalMethodType.setURI(retrievalMethodKDV.getKeyDataValueString()); | |
| } else { | |
| throw new RuntimeException("Unrecognized key data type: " + retrievalMethodKDV.getKeyDataType()); | |
| } | |
| } | |
| if (transformsType.getTransform() != null && !transformsType.getTransform().isEmpty()) { | |
| retrievalMethodType.setTransforms(transformsType); | |
| } | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), RetrievalMethodType.class, retrievalMethodType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else if (dataType.equals(PGPDataType.class.getSimpleName())) { | |
| PGPDataType pgpDataType = new PGPDataType(); | |
| for (KeyDataValue pgpDataKDV : modelKeyDataValue.getKeyDataValueList()) { | |
| String pgpDataTagName = pgpDataKDV.getKeyDataName(); | |
| Object pgpDataContents = pgpDataKDV.getKeyDataValueBytes() != null ? pgpDataKDV.getKeyDataValueBytes() : pgpDataKDV.getKeyDataValueString(); | |
| Class pgpDataClazz = pgpDataContents.getClass(); | |
| JAXBElement jaxb = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", pgpDataTagName), pgpDataClazz, pgpDataContents); | |
| pgpDataType.getContent().add(jaxb); | |
| } | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), PGPDataType.class, pgpDataType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else if (dataType.equals(SPKIDataType.class.getSimpleName())) { | |
| SPKIDataType spkiDataType = new SPKIDataType(); | |
| for (KeyDataValue spkiDataKDV : modelKeyDataValue.getKeyDataValueList()) { | |
| String spkiDataTagName = spkiDataKDV.getKeyDataName(); | |
| Object spkiDataContents = spkiDataKDV.getKeyDataValueBytes() != null ? spkiDataKDV.getKeyDataValueBytes() : spkiDataKDV.getKeyDataValueString(); | |
| Class spkiDataClazz = spkiDataContents.getClass(); | |
| JAXBElement jaxb = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", spkiDataTagName), spkiDataClazz, spkiDataContents); | |
| spkiDataType.getSPKISexpAndAny().add(jaxb); | |
| } | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), SPKIDataType.class, spkiDataType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else if (dataType.equals(KeyValueType.class.getSimpleName())) { | |
| KeyValueType keyValueType = new KeyValueType(); | |
| for (KeyDataValue keyValueDataKDV : modelKeyDataValue.getKeyDataValueList()) { | |
| for (KeyDataValue keyValueDataChildKDV : keyValueDataKDV.getKeyDataValueList()) { | |
| String keyDataDataType = keyValueDataChildKDV.getKeyDataType(); | |
| if (keyDataDataType.equals("DSAKeyValueType")) { | |
| DSAKeyValueType dsaKeyValueType = new DSAKeyValueType(); | |
| for (KeyDataValue dsaKDV : keyValueDataChildKDV.getKeyDataValueList()) { | |
| if ("G".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setG(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("P".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setP(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("Q".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setQ(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("Y".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setY(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("J".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setJ(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("Seed".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setSeed(dsaKDV.getKeyDataValueBytes()); | |
| } else if ("PgenCounter".equals(dsaKDV.getKeyDataName())) { | |
| dsaKeyValueType.setPgenCounter(dsaKDV.getKeyDataValueBytes()); | |
| } else { | |
| throw new RuntimeException("Unrecognized dsa type: " + dsaKDV.getKeyDataName()); | |
| } | |
| } | |
| JAXBElement jaxb = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", keyValueDataChildKDV.getKeyDataName()), DSAKeyValueType.class, dsaKeyValueType); | |
| keyValueType.getContent().add(jaxb); | |
| } else if (keyDataDataType.equals("RSAKeyValueType")) { | |
| RSAKeyValueType rsaKeyValueType = new RSAKeyValueType(); | |
| for (KeyDataValue rsaKDV : keyValueDataChildKDV.getKeyDataValueList()) { | |
| if ("Exponent".equals(rsaKDV.getKeyDataName())) { | |
| rsaKeyValueType.setExponent(rsaKDV.getKeyDataValueBytes()); | |
| } else if ("Modulus".equals(rsaKDV.getKeyDataName())) { | |
| rsaKeyValueType.setModulus(rsaKDV.getKeyDataValueBytes()); | |
| } else { | |
| throw new RuntimeException("Unrecognized dsa type: " + rsaKDV.getKeyDataName()); | |
| } | |
| } | |
| JAXBElement jaxb = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", keyValueDataChildKDV.getKeyDataName()), RSAKeyValueType.class, rsaKeyValueType); | |
| keyValueType.getContent().add(jaxb); | |
| } else { | |
| throw new RuntimeException("Unrecognized element: " + keyDataDataType); | |
| } | |
| } | |
| } | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), KeyValueType.class, keyValueType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else { | |
| throw new RuntimeException("Unrecognized type: " + dataType); | |
| } | |
| } else { | |
| if (dataType != null && dataType.equals(X509IssuerSerialType.class.getSimpleName())) { | |
| X509IssuerSerialType x509IssuerSerialType = new X509IssuerSerialType(); | |
| x509IssuerSerialType.setX509IssuerName(contentStr); | |
| x509IssuerSerialType.setX509SerialNumber(new BigInteger(contentBytes)); | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), X509IssuerSerialType.class, x509IssuerSerialType); | |
| parentKeyDataList.add(dataJAXB); | |
| } else { | |
| JAXBElement dataJAXB = new JAXBElement(new QName("http://www.w3.org/2000/09/xmldsig#", tagName), contents.getClass(), contents); | |
| parentKeyDataList.add(dataJAXB); | |
| } | |
| } | |
| } | |
| } | |
| public static void mapBusinessNames(List<org.apache.juddi.model.BusinessName> modelNameList, | |
| List<org.uddi.api_v3.Name> apiNameList) | |
| throws DispositionReportFaultMessage { | |
| apiNameList.clear(); | |
| for (org.apache.juddi.model.BusinessName modelName : modelNameList) { | |
| org.uddi.api_v3.Name apiName = new org.uddi.api_v3.Name(); | |
| apiName.setLang(modelName.getLangCode()); | |
| apiName.setValue(modelName.getName()); | |
| apiNameList.add(apiName); | |
| } | |
| } | |
| public static void mapBusinessDescriptions(List<org.apache.juddi.model.BusinessDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.BusinessDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static void mapDiscoveryUrls(List<org.apache.juddi.model.DiscoveryUrl> modelDiscUrlList, | |
| org.uddi.api_v3.DiscoveryURLs apiDiscUrls, | |
| org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| throws DispositionReportFaultMessage { | |
| if (modelDiscUrlList == null || modelDiscUrlList.size() == 0) { | |
| return; | |
| } | |
| if (apiDiscUrls == null) { | |
| apiDiscUrls = new org.uddi.api_v3.DiscoveryURLs(); | |
| } | |
| List<org.uddi.api_v3.DiscoveryURL> apiDiscUrlList = apiDiscUrls.getDiscoveryURL(); | |
| apiDiscUrlList.clear(); | |
| for (org.apache.juddi.model.DiscoveryUrl modelDiscUrl : modelDiscUrlList) { | |
| org.uddi.api_v3.DiscoveryURL apiDiscUrl = new org.uddi.api_v3.DiscoveryURL(); | |
| apiDiscUrl.setUseType(modelDiscUrl.getUseType()); | |
| String discoveryURL = modelDiscUrl.getUrl(); | |
| try { | |
| String baseUrl = AppConfig.getConfiguration().getString(Property.JUDDI_BASE_URL); | |
| if (baseUrl == null) { | |
| logger.warn("Token '" + Property.JUDDI_BASE_URL + "' not found in the juddiv3.xml, defaulting to '" | |
| + Property.DEFAULT_BASE_URL + "'"); | |
| baseUrl = Property.DEFAULT_BASE_URL; | |
| } | |
| discoveryURL = discoveryURL.replaceAll("\\$\\{" + Property.JUDDI_BASE_URL + "\\}", baseUrl); | |
| baseUrl = AppConfig.getConfiguration().getString(Property.JUDDI_BASE_URL_SECURE); | |
| if (baseUrl == null) { | |
| logger.warn("Token '" + Property.JUDDI_BASE_URL_SECURE + "' not found in the juddiv3.xml, defaulting to '" | |
| + Property.JUDDI_BASE_URL_SECURE + "'"); | |
| baseUrl = Property.DEFAULT_BASE_URL_SECURE; | |
| } | |
| discoveryURL = discoveryURL.replaceAll("\\$\\{" + Property.JUDDI_BASE_URL_SECURE + "\\}", baseUrl); | |
| } catch (ConfigurationException e) { | |
| logger.error(e.getMessage(), e); | |
| } | |
| apiDiscUrl.setValue(discoveryURL); | |
| apiDiscUrlList.add(apiDiscUrl); | |
| } | |
| apiBusinessEntity.setDiscoveryURLs(apiDiscUrls); | |
| } | |
| public static void mapContact(org.apache.juddi.model.Contact modelContact, | |
| org.uddi.api_v3.Contact apiContact) throws DispositionReportFaultMessage { | |
| if (apiContact == null) { | |
| apiContact = new org.uddi.api_v3.Contact(); | |
| } | |
| apiContact.setUseType(modelContact.getUseType()); | |
| mapPersonNames(modelContact.getPersonNames(), apiContact.getPersonName()); | |
| mapContactDescriptions(modelContact.getContactDescrs(), apiContact.getDescription()); | |
| mapContactEmails(modelContact.getEmails(), apiContact.getEmail()); | |
| mapContactPhones(modelContact.getPhones(), apiContact.getPhone()); | |
| mapContactAddresses(modelContact.getAddresses(), apiContact.getAddress()); | |
| } | |
| public static void mapContacts(List<org.apache.juddi.model.Contact> modelContactList, | |
| org.uddi.api_v3.Contacts apiContacts, | |
| org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| throws DispositionReportFaultMessage { | |
| if (modelContactList == null || modelContactList.size() == 0) { | |
| return; | |
| } | |
| if (apiContacts == null) { | |
| apiContacts = new org.uddi.api_v3.Contacts(); | |
| } | |
| List<org.uddi.api_v3.Contact> apiContactList = apiContacts.getContact(); | |
| apiContactList.clear(); | |
| for (org.apache.juddi.model.Contact modelContact : modelContactList) { | |
| org.uddi.api_v3.Contact apiContact = new org.uddi.api_v3.Contact(); | |
| mapContact(modelContact,apiContact); | |
| apiContactList.add(apiContact); | |
| } | |
| apiBusinessEntity.setContacts(apiContacts); | |
| } | |
| public static void mapContactDescriptions(List<org.apache.juddi.model.ContactDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.ContactDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static void mapPersonNames(List<org.apache.juddi.model.PersonName> modelPersonNameList, | |
| List<org.uddi.api_v3.PersonName> apiPersonNameList) | |
| throws DispositionReportFaultMessage { | |
| apiPersonNameList.clear(); | |
| for (org.apache.juddi.model.PersonName personName : modelPersonNameList) { | |
| org.uddi.api_v3.PersonName apiPersonName = new org.uddi.api_v3.PersonName(); | |
| apiPersonName.setLang(personName.getLangCode()); | |
| apiPersonName.setValue(personName.getName()); | |
| apiPersonNameList.add(apiPersonName); | |
| } | |
| } | |
| public static void mapContactEmails(List<org.apache.juddi.model.Email> modelEmailList, | |
| List<org.uddi.api_v3.Email> apiEmailList) | |
| throws DispositionReportFaultMessage { | |
| apiEmailList.clear(); | |
| for (org.apache.juddi.model.Email modelEmail : modelEmailList) { | |
| org.uddi.api_v3.Email apiEmail = new org.uddi.api_v3.Email(); | |
| apiEmail.setUseType(modelEmail.getUseType()); | |
| apiEmail.setValue(modelEmail.getEmailAddress()); | |
| apiEmailList.add(apiEmail); | |
| } | |
| } | |
| public static void mapContactPhones(List<org.apache.juddi.model.Phone> modelPhoneList, | |
| List<org.uddi.api_v3.Phone> apiPhoneList) | |
| throws DispositionReportFaultMessage { | |
| apiPhoneList.clear(); | |
| for (org.apache.juddi.model.Phone modelPhone : modelPhoneList) { | |
| org.uddi.api_v3.Phone apiPhone = new org.uddi.api_v3.Phone(); | |
| apiPhone.setUseType(modelPhone.getUseType()); | |
| apiPhone.setValue(modelPhone.getPhoneNumber()); | |
| apiPhoneList.add(apiPhone); | |
| } | |
| } | |
| public static void mapContactAddresses(List<org.apache.juddi.model.Address> modelAddressList, | |
| List<org.uddi.api_v3.Address> apiAddressList) | |
| throws DispositionReportFaultMessage { | |
| apiAddressList.clear(); | |
| for (org.apache.juddi.model.Address modelAddress : modelAddressList) { | |
| org.uddi.api_v3.Address apiAddress = new org.uddi.api_v3.Address(); | |
| apiAddress.setUseType(modelAddress.getUseType()); | |
| apiAddress.setLang(""); | |
| apiAddress.setSortCode(modelAddress.getSortCode()); | |
| apiAddress.setTModelKey(modelAddress.getTmodelKey()); | |
| mapAddressLines(modelAddress.getAddressLines(), apiAddress.getAddressLine()); | |
| apiAddressList.add(apiAddress); | |
| } | |
| } | |
| public static void mapAddressLines(List<org.apache.juddi.model.AddressLine> modelAddressLineList, | |
| List<org.uddi.api_v3.AddressLine> apiAddressLineList) | |
| throws DispositionReportFaultMessage { | |
| apiAddressLineList.clear(); | |
| for (org.apache.juddi.model.AddressLine modelAddressLine : modelAddressLineList) { | |
| org.uddi.api_v3.AddressLine apiAddressLine = new org.uddi.api_v3.AddressLine(); | |
| apiAddressLine.setKeyName(modelAddressLine.getKeyName()); | |
| apiAddressLine.setKeyValue(modelAddressLine.getKeyValue()); | |
| apiAddressLine.setValue(modelAddressLine.getLine()); | |
| apiAddressLineList.add(apiAddressLine); | |
| } | |
| } | |
| public static void mapBusinessIdentifiers(List<org.apache.juddi.model.BusinessIdentifier> modelIdentifierList, | |
| org.uddi.api_v3.IdentifierBag apiIdentifierBag, | |
| org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| throws DispositionReportFaultMessage { | |
| if (modelIdentifierList == null || modelIdentifierList.size() == 0) { | |
| return; | |
| } | |
| if (apiIdentifierBag == null) { | |
| apiIdentifierBag = new org.uddi.api_v3.IdentifierBag(); | |
| } | |
| List<org.uddi.api_v3.KeyedReference> apiKeyedRefList = apiIdentifierBag.getKeyedReference(); | |
| apiKeyedRefList.clear(); | |
| for (org.apache.juddi.model.BusinessIdentifier modelIdentifier : modelIdentifierList) { | |
| org.uddi.api_v3.KeyedReference apiKeyedRef = new org.uddi.api_v3.KeyedReference(); | |
| apiKeyedRef.setTModelKey(modelIdentifier.getTmodelKeyRef()); | |
| apiKeyedRef.setKeyName(modelIdentifier.getKeyName()); | |
| apiKeyedRef.setKeyValue(modelIdentifier.getKeyValue()); | |
| apiKeyedRefList.add(apiKeyedRef); | |
| } | |
| apiBusinessEntity.setIdentifierBag(apiIdentifierBag); | |
| } | |
| public static void mapBusinessServices(List<org.apache.juddi.model.BusinessService> modelBusinessServiceList, | |
| List<org.apache.juddi.model.ServiceProjection> modelServiceProjectionList, | |
| org.uddi.api_v3.BusinessServices apiBusinessServices, | |
| org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| throws DispositionReportFaultMessage { | |
| if (apiBusinessServices == null) { | |
| apiBusinessServices = new org.uddi.api_v3.BusinessServices(); | |
| } | |
| List<org.uddi.api_v3.BusinessService> apiBusinessServiceList = apiBusinessServices.getBusinessService(); | |
| apiBusinessServiceList.clear(); | |
| if (modelBusinessServiceList != null && modelBusinessServiceList.size() > 0) { | |
| for (org.apache.juddi.model.BusinessService modelBusinessService : modelBusinessServiceList) { | |
| org.uddi.api_v3.BusinessService apiBusinessService = new org.uddi.api_v3.BusinessService(); | |
| mapBusinessService(modelBusinessService, apiBusinessService); | |
| apiBusinessServiceList.add(apiBusinessService); | |
| } | |
| } | |
| if (modelServiceProjectionList != null && modelServiceProjectionList.size() > 0) { | |
| for (org.apache.juddi.model.ServiceProjection modelServiceProjection : modelServiceProjectionList) { | |
| org.uddi.api_v3.BusinessService apiBusinessService = new org.uddi.api_v3.BusinessService(); | |
| mapBusinessService(modelServiceProjection.getBusinessService(), apiBusinessService); | |
| apiBusinessServiceList.add(apiBusinessService); | |
| } | |
| } | |
| if (apiBusinessServiceList.size() > 0) { | |
| apiBusinessEntity.setBusinessServices(apiBusinessServices); | |
| } | |
| } | |
| public static void mapBusinessService(org.apache.juddi.model.BusinessService modelBusinessService, | |
| org.uddi.api_v3.BusinessService apiBusinessService) | |
| throws DispositionReportFaultMessage { | |
| apiBusinessService.setBusinessKey(modelBusinessService.getBusinessEntity().getEntityKey()); | |
| apiBusinessService.setServiceKey(modelBusinessService.getEntityKey()); | |
| mapServiceNames(modelBusinessService.getServiceNames(), apiBusinessService.getName()); | |
| mapServiceDescriptions(modelBusinessService.getServiceDescrs(), apiBusinessService.getDescription()); | |
| mapBindingTemplates(modelBusinessService.getBindingTemplates(), apiBusinessService.getBindingTemplates(), apiBusinessService); | |
| apiBusinessService.setCategoryBag(mapCategoryBag(modelBusinessService.getCategoryBag(), apiBusinessService.getCategoryBag())); | |
| mapSignature(modelBusinessService.getSignatures(), apiBusinessService.getSignature()); | |
| } | |
| public static void mapServiceNames(List<org.apache.juddi.model.ServiceName> modelNameList, | |
| List<org.uddi.api_v3.Name> apiNameList) | |
| throws DispositionReportFaultMessage { | |
| apiNameList.clear(); | |
| for (org.apache.juddi.model.ServiceName modelName : modelNameList) { | |
| org.uddi.api_v3.Name apiName = new org.uddi.api_v3.Name(); | |
| apiName.setLang(modelName.getLangCode()); | |
| apiName.setValue(modelName.getName()); | |
| apiNameList.add(apiName); | |
| } | |
| } | |
| public static void mapServiceDescriptions(List<org.apache.juddi.model.ServiceDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.ServiceDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static void mapBindingTemplates(List<org.apache.juddi.model.BindingTemplate> modelBindingTemplateList, | |
| org.uddi.api_v3.BindingTemplates apiBindingTemplates, | |
| org.uddi.api_v3.BusinessService apiBusinessService) | |
| throws DispositionReportFaultMessage { | |
| if (modelBindingTemplateList == null || modelBindingTemplateList.size() == 0) { | |
| return; | |
| } | |
| if (apiBindingTemplates == null) { | |
| apiBindingTemplates = new org.uddi.api_v3.BindingTemplates(); | |
| } | |
| List<org.uddi.api_v3.BindingTemplate> apiBindingTemplateList = apiBindingTemplates.getBindingTemplate(); | |
| apiBindingTemplateList.clear(); | |
| for (org.apache.juddi.model.BindingTemplate modelBindingTemplate : modelBindingTemplateList) { | |
| org.uddi.api_v3.BindingTemplate apiBindingTemplate = new org.uddi.api_v3.BindingTemplate(); | |
| mapBindingTemplate(modelBindingTemplate, apiBindingTemplate); | |
| apiBindingTemplateList.add(apiBindingTemplate); | |
| } | |
| apiBusinessService.setBindingTemplates(apiBindingTemplates); | |
| } | |
| public static void mapBindingTemplate(org.apache.juddi.model.BindingTemplate modelBindingTemplate, | |
| org.uddi.api_v3.BindingTemplate apiBindingTemplate) | |
| throws DispositionReportFaultMessage { | |
| apiBindingTemplate.setServiceKey(modelBindingTemplate.getBusinessService().getEntityKey()); | |
| apiBindingTemplate.setBindingKey(modelBindingTemplate.getEntityKey()); | |
| org.uddi.api_v3.AccessPoint apiAccessPoint = new org.uddi.api_v3.AccessPoint(); | |
| apiAccessPoint.setUseType(modelBindingTemplate.getAccessPointType()); | |
| String accessPointValue = modelBindingTemplate.getAccessPointUrl(); | |
| if (accessPointValue != null) { | |
| try { | |
| String baseUrl = AppConfig.getConfiguration().getString(Property.JUDDI_BASE_URL); | |
| if (baseUrl == null) { | |
| logger.warn("Token '" + Property.JUDDI_BASE_URL + "' not found in the juddiv3.xml, defaulting to '" | |
| + Property.DEFAULT_BASE_URL + "'"); | |
| baseUrl = Property.DEFAULT_BASE_URL; | |
| } | |
| accessPointValue = accessPointValue.replaceAll("\\$\\{" + Property.JUDDI_BASE_URL + "\\}", baseUrl); | |
| baseUrl = AppConfig.getConfiguration().getString(Property.JUDDI_BASE_URL_SECURE); | |
| if (baseUrl == null) { | |
| logger.warn("Token '" + Property.JUDDI_BASE_URL_SECURE + "' not found in the juddiv3.xml, defaulting to '" | |
| + Property.JUDDI_BASE_URL_SECURE + "'"); | |
| baseUrl = Property.DEFAULT_BASE_URL_SECURE; | |
| } | |
| accessPointValue = accessPointValue.replaceAll("\\$\\{" + Property.JUDDI_BASE_URL_SECURE + "\\}", baseUrl); | |
| } catch (ConfigurationException e) { | |
| logger.error(e.getMessage(), e); | |
| } | |
| } | |
| apiAccessPoint.setValue(accessPointValue); | |
| apiBindingTemplate.setAccessPoint(apiAccessPoint); | |
| if (modelBindingTemplate.getHostingRedirector() != null) { | |
| org.uddi.api_v3.HostingRedirector apiHost = new org.uddi.api_v3.HostingRedirector(); | |
| apiHost.setBindingKey(modelBindingTemplate.getHostingRedirector()); | |
| apiBindingTemplate.setHostingRedirector(apiHost); | |
| } | |
| mapTModelInstanceDetails(modelBindingTemplate.getTmodelInstanceInfos(), apiBindingTemplate.getTModelInstanceDetails(), apiBindingTemplate); | |
| mapBindingDescriptions(modelBindingTemplate.getBindingDescrs(), apiBindingTemplate.getDescription()); | |
| apiBindingTemplate.setCategoryBag(mapCategoryBag(modelBindingTemplate.getCategoryBag(), apiBindingTemplate.getCategoryBag())); | |
| mapSignature(modelBindingTemplate.getSignatures(), apiBindingTemplate.getSignature()); | |
| } | |
| public static void mapBindingDescriptions(List<org.apache.juddi.model.BindingDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.BindingDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static org.uddi.api_v3.CategoryBag mapCategoryBag(org.apache.juddi.model.CategoryBag modelCategoryBag, | |
| org.uddi.api_v3.CategoryBag apiCategoryBag) | |
| throws DispositionReportFaultMessage { | |
| if (modelCategoryBag != null) { | |
| if (apiCategoryBag == null) { | |
| apiCategoryBag = new org.uddi.api_v3.CategoryBag(); | |
| } | |
| for (org.apache.juddi.model.KeyedReference modelKeyedReference : modelCategoryBag.getKeyedReferences()) { | |
| org.uddi.api_v3.KeyedReference apiKeyedReference = new org.uddi.api_v3.KeyedReference(); | |
| apiKeyedReference.setTModelKey(modelKeyedReference.getTmodelKeyRef()); | |
| apiKeyedReference.setKeyName(modelKeyedReference.getKeyName()); | |
| apiKeyedReference.setKeyValue(modelKeyedReference.getKeyValue()); | |
| apiCategoryBag.getKeyedReference().add(apiKeyedReference); | |
| } | |
| for (org.apache.juddi.model.KeyedReferenceGroup modelKeyedReferenceGroup : modelCategoryBag.getKeyedReferenceGroups()) { | |
| org.uddi.api_v3.KeyedReferenceGroup apiKeyedReferenceGroup = new org.uddi.api_v3.KeyedReferenceGroup(); | |
| mapKeyedReferenceGroup(modelKeyedReferenceGroup, apiKeyedReferenceGroup); | |
| apiCategoryBag.getKeyedReferenceGroup().add(apiKeyedReferenceGroup); | |
| } | |
| } | |
| return apiCategoryBag; | |
| } | |
| public static void mapKeyedReferenceGroup(org.apache.juddi.model.KeyedReferenceGroup modelKeyedReferenceGroup, | |
| org.uddi.api_v3.KeyedReferenceGroup apiKeyedReferenceGroup) | |
| throws DispositionReportFaultMessage { | |
| apiKeyedReferenceGroup.setTModelKey(modelKeyedReferenceGroup.getTmodelKey()); | |
| for (org.apache.juddi.model.KeyedReference modelKeyedReference : modelKeyedReferenceGroup.getKeyedReferences()) { | |
| org.uddi.api_v3.KeyedReference apiKeyedReference = new org.uddi.api_v3.KeyedReference(); | |
| apiKeyedReference.setTModelKey(modelKeyedReference.getTmodelKeyRef()); | |
| apiKeyedReference.setKeyName(modelKeyedReference.getKeyName()); | |
| apiKeyedReference.setKeyValue(modelKeyedReference.getKeyValue()); | |
| apiKeyedReferenceGroup.getKeyedReference().add(apiKeyedReference); | |
| } | |
| } | |
| public static void mapTModelInstanceDetails(List<org.apache.juddi.model.TmodelInstanceInfo> modelTModelInstInfoList, | |
| org.uddi.api_v3.TModelInstanceDetails apiTModelInstDetails, | |
| org.uddi.api_v3.BindingTemplate apiBindingTemplate) | |
| throws DispositionReportFaultMessage { | |
| if (modelTModelInstInfoList == null || modelTModelInstInfoList.size() == 0) { | |
| return; | |
| } | |
| if (apiTModelInstDetails == null) { | |
| apiTModelInstDetails = new org.uddi.api_v3.TModelInstanceDetails(); | |
| } | |
| List<org.uddi.api_v3.TModelInstanceInfo> apiTModelInstInfoList = apiTModelInstDetails.getTModelInstanceInfo(); | |
| apiTModelInstInfoList.clear(); | |
| for (org.apache.juddi.model.TmodelInstanceInfo modelTModelInstInfo : modelTModelInstInfoList) { | |
| org.uddi.api_v3.TModelInstanceInfo apiTModelInstInfo = new org.uddi.api_v3.TModelInstanceInfo(); | |
| apiTModelInstInfo.setTModelKey(modelTModelInstInfo.getTmodelKey()); | |
| mapTModelInstanceInfoDescriptions(modelTModelInstInfo.getTmodelInstanceInfoDescrs(), apiTModelInstInfo.getDescription()); | |
| mapInstanceDetails(modelTModelInstInfo, apiTModelInstInfo.getInstanceDetails(), apiTModelInstInfo); | |
| apiTModelInstInfoList.add(apiTModelInstInfo); | |
| } | |
| apiBindingTemplate.setTModelInstanceDetails(apiTModelInstDetails); | |
| } | |
| public static void mapTModelInstanceInfoDescriptions(List<org.apache.juddi.model.TmodelInstanceInfoDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.TmodelInstanceInfoDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static void mapInstanceDetails(org.apache.juddi.model.TmodelInstanceInfo modelTModelInstInfo, | |
| org.uddi.api_v3.InstanceDetails apiInstanceDetails, | |
| org.uddi.api_v3.TModelInstanceInfo apiTModelInstInfo) | |
| throws DispositionReportFaultMessage { | |
| if (modelTModelInstInfo == null | |
| || (modelTModelInstInfo.getInstanceParms() == null && modelTModelInstInfo.getOverviewDocs().size() == 0)) { | |
| return; | |
| } | |
| if (apiInstanceDetails == null) { | |
| apiInstanceDetails = new org.uddi.api_v3.InstanceDetails(); | |
| } | |
| //InstanceParms | |
| apiInstanceDetails.setInstanceParms(modelTModelInstInfo.getInstanceParms()); | |
| //Descriptions | |
| List<org.apache.juddi.model.InstanceDetailsDescr> modelInstDetailsDescrList = modelTModelInstInfo.getInstanceDetailsDescrs(); | |
| for (org.apache.juddi.model.InstanceDetailsDescr modelInstDetailDescr : modelInstDetailsDescrList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelInstDetailDescr.getLangCode()); | |
| apiDesc.setValue(modelInstDetailDescr.getDescr()); | |
| apiInstanceDetails.getDescription().add(apiDesc); | |
| } | |
| //OverviewDoc | |
| mapOverviewDocs(modelTModelInstInfo.getOverviewDocs(), apiInstanceDetails, null); | |
| apiTModelInstInfo.setInstanceDetails(apiInstanceDetails); | |
| } | |
| public static void mapOverviewDocs(List<org.apache.juddi.model.OverviewDoc> modelOverviewDocs, | |
| org.uddi.api_v3.InstanceDetails apiInstanceDetails, | |
| org.uddi.api_v3.TModel apiTModel) { | |
| for (OverviewDoc modelOverviewDoc : modelOverviewDocs) { | |
| org.uddi.api_v3.OverviewDoc apiOverviewDoc = new org.uddi.api_v3.OverviewDoc(); | |
| //Descriptions | |
| List<org.apache.juddi.model.OverviewDocDescr> overviewDocDescrList = modelOverviewDoc.getOverviewDocDescrs(); | |
| for (org.apache.juddi.model.OverviewDocDescr overviewDocDescr : overviewDocDescrList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(overviewDocDescr.getLangCode()); | |
| apiDesc.setValue(overviewDocDescr.getDescr()); | |
| apiOverviewDoc.getDescription().add(apiDesc); | |
| } | |
| //OverviewURL | |
| org.uddi.api_v3.OverviewURL apiOverviewURL = new org.uddi.api_v3.OverviewURL(); | |
| apiOverviewURL.setUseType(modelOverviewDoc.getOverviewUrlUseType()); | |
| apiOverviewURL.setValue(modelOverviewDoc.getOverviewUrl()); | |
| apiOverviewDoc.setOverviewURL(apiOverviewURL); | |
| //Set the entity on the apiOverviewDoc | |
| if (apiInstanceDetails != null) { | |
| apiInstanceDetails.getOverviewDoc().add(apiOverviewDoc); | |
| } else { | |
| apiTModel.getOverviewDoc().add(apiOverviewDoc); | |
| } | |
| } | |
| } | |
| public static void mapTModel(org.apache.juddi.model.Tmodel modelTModel, | |
| org.uddi.api_v3.TModel apiTModel) | |
| throws DispositionReportFaultMessage { | |
| apiTModel.setTModelKey(modelTModel.getEntityKey()); | |
| org.uddi.api_v3.Name apiName = new org.uddi.api_v3.Name(); | |
| apiName.setValue(modelTModel.getName()); | |
| apiName.setLang(modelTModel.getLangCode()); | |
| apiTModel.setName(apiName); | |
| apiTModel.setDeleted(modelTModel.getDeleted()); | |
| mapTModelDescriptions(modelTModel.getTmodelDescrs(), apiTModel.getDescription()); | |
| mapTModelIdentifiers(modelTModel.getTmodelIdentifiers(), apiTModel.getIdentifierBag(), apiTModel); | |
| apiTModel.setCategoryBag(mapCategoryBag(modelTModel.getCategoryBag(), apiTModel.getCategoryBag())); | |
| mapOverviewDocs(modelTModel.getOverviewDocs(), null, apiTModel); | |
| mapSignature(modelTModel.getSignatures(), apiTModel.getSignature()); | |
| } | |
| public static void mapTModelDescriptions(List<org.apache.juddi.model.TmodelDescr> modelDescList, | |
| List<org.uddi.api_v3.Description> apiDescList) | |
| throws DispositionReportFaultMessage { | |
| apiDescList.clear(); | |
| for (org.apache.juddi.model.TmodelDescr modelDesc : modelDescList) { | |
| org.uddi.api_v3.Description apiDesc = new org.uddi.api_v3.Description(); | |
| apiDesc.setLang(modelDesc.getLangCode()); | |
| apiDesc.setValue(modelDesc.getDescr()); | |
| apiDescList.add(apiDesc); | |
| } | |
| } | |
| public static void mapTModelIdentifiers(List<org.apache.juddi.model.TmodelIdentifier> modelIdentifierList, | |
| org.uddi.api_v3.IdentifierBag apiIdentifierBag, | |
| org.uddi.api_v3.TModel apiTModel) | |
| throws DispositionReportFaultMessage { | |
| if (modelIdentifierList == null || modelIdentifierList.size() == 0) { | |
| return; | |
| } | |
| if (apiIdentifierBag == null) { | |
| apiIdentifierBag = new org.uddi.api_v3.IdentifierBag(); | |
| } | |
| List<org.uddi.api_v3.KeyedReference> apiKeyedRefList = apiIdentifierBag.getKeyedReference(); | |
| apiKeyedRefList.clear(); | |
| for (org.apache.juddi.model.TmodelIdentifier modelIdentifier : modelIdentifierList) { | |
| org.uddi.api_v3.KeyedReference apiKeyedRef = new org.uddi.api_v3.KeyedReference(); | |
| apiKeyedRef.setTModelKey(modelIdentifier.getTmodelKeyRef()); | |
| apiKeyedRef.setKeyName(modelIdentifier.getKeyName()); | |
| apiKeyedRef.setKeyValue(modelIdentifier.getKeyValue()); | |
| apiKeyedRefList.add(apiKeyedRef); | |
| } | |
| apiTModel.setIdentifierBag(apiIdentifierBag); | |
| } | |
| public static void mapBusinessInfo(org.apache.juddi.model.BusinessEntity modelBusinessEntity, | |
| org.uddi.api_v3.BusinessInfo apiBusinessInfo) | |
| throws DispositionReportFaultMessage { | |
| apiBusinessInfo.setBusinessKey(modelBusinessEntity.getEntityKey()); | |
| mapBusinessNames(modelBusinessEntity.getBusinessNames(), apiBusinessInfo.getName()); | |
| mapBusinessDescriptions(modelBusinessEntity.getBusinessDescrs(), apiBusinessInfo.getDescription()); | |
| mapServiceInfos(modelBusinessEntity.getBusinessServices(), apiBusinessInfo.getServiceInfos(), apiBusinessInfo); | |
| } | |
| public static void mapServiceInfos(List<org.apache.juddi.model.BusinessService> modelBusinessServiceList, | |
| org.uddi.api_v3.ServiceInfos apiServiceInfos, | |
| org.uddi.api_v3.BusinessInfo apiBusinessInfo) | |
| throws DispositionReportFaultMessage { | |
| if (modelBusinessServiceList.size() == 0) { | |
| return; | |
| } | |
| if (apiServiceInfos == null) { | |
| apiServiceInfos = new org.uddi.api_v3.ServiceInfos(); | |
| } | |
| List<org.uddi.api_v3.ServiceInfo> apiServiceInfoList = apiServiceInfos.getServiceInfo(); | |
| apiServiceInfoList.clear(); | |
| for (org.apache.juddi.model.BusinessService modelBusinessService : modelBusinessServiceList) { | |
| org.uddi.api_v3.ServiceInfo apiServiceInfo = new org.uddi.api_v3.ServiceInfo(); | |
| mapServiceInfo(modelBusinessService, apiServiceInfo); | |
| apiServiceInfos.getServiceInfo().add(apiServiceInfo); | |
| } | |
| apiBusinessInfo.setServiceInfos(apiServiceInfos); | |
| } | |
| public static void mapServiceInfo(org.apache.juddi.model.BusinessService modelBusinessService, | |
| org.uddi.api_v3.ServiceInfo apiServiceInfo) | |
| throws DispositionReportFaultMessage { | |
| apiServiceInfo.setBusinessKey(modelBusinessService.getBusinessEntity().getEntityKey()); | |
| apiServiceInfo.setServiceKey(modelBusinessService.getEntityKey()); | |
| mapServiceNames(modelBusinessService.getServiceNames(), apiServiceInfo.getName()); | |
| } | |
| public static void mapTModelInfo(org.apache.juddi.model.Tmodel modelTModel, | |
| org.uddi.api_v3.TModelInfo apiTModelInfo) | |
| throws DispositionReportFaultMessage { | |
| apiTModelInfo.setTModelKey(modelTModel.getEntityKey()); | |
| org.uddi.api_v3.Name apiName = new org.uddi.api_v3.Name(); | |
| apiName.setValue(modelTModel.getName()); | |
| apiName.setLang(modelTModel.getLangCode()); | |
| apiTModelInfo.setName(apiName); | |
| mapTModelDescriptions(modelTModel.getTmodelDescrs(), apiTModelInfo.getDescription()); | |
| } | |
| public static void mapAuthToken(org.apache.juddi.model.AuthToken modelAuthToken, | |
| org.uddi.api_v3.AuthToken apiAuthToken) | |
| throws DispositionReportFaultMessage { | |
| apiAuthToken.setAuthInfo(modelAuthToken.getAuthToken()); | |
| } | |
| public static void mapPublisherAssertion(org.apache.juddi.model.PublisherAssertion modelPublisherAssertion, | |
| org.uddi.api_v3.PublisherAssertion apiPublisherAssertion) | |
| throws DispositionReportFaultMessage { | |
| apiPublisherAssertion.setFromKey(modelPublisherAssertion.getId().getFromKey()); | |
| apiPublisherAssertion.setToKey(modelPublisherAssertion.getId().getToKey()); | |
| org.uddi.api_v3.KeyedReference keyedRef = new org.uddi.api_v3.KeyedReference(); | |
| keyedRef.setTModelKey(modelPublisherAssertion.getTmodelKey()); | |
| keyedRef.setKeyName(modelPublisherAssertion.getKeyName()); | |
| keyedRef.setKeyValue(modelPublisherAssertion.getKeyValue()); | |
| if (modelPublisherAssertion.getSignatures()!=null && | |
| !modelPublisherAssertion.getSignatures().isEmpty()) | |
| { | |
| mapSignature(modelPublisherAssertion.getSignatures(), apiPublisherAssertion.getSignature()); | |
| } | |
| apiPublisherAssertion.setKeyedReference(keyedRef); | |
| } | |
| public static void mapAssertionStatusItem(org.apache.juddi.model.PublisherAssertion modelPublisherAssertion, | |
| org.uddi.api_v3.AssertionStatusItem apiAssertionStatusItem, | |
| List<?> businessKeys) | |
| throws DispositionReportFaultMessage { | |
| apiAssertionStatusItem.setFromKey(modelPublisherAssertion.getId().getFromKey()); | |
| apiAssertionStatusItem.setToKey(modelPublisherAssertion.getId().getToKey()); | |
| org.uddi.api_v3.KeyedReference keyedRef = new org.uddi.api_v3.KeyedReference(); | |
| keyedRef.setTModelKey(modelPublisherAssertion.getTmodelKey()); | |
| keyedRef.setKeyName(modelPublisherAssertion.getKeyName()); | |
| keyedRef.setKeyValue(modelPublisherAssertion.getKeyValue()); | |
| apiAssertionStatusItem.setKeyedReference(keyedRef); | |
| if ("true".equalsIgnoreCase(modelPublisherAssertion.getFromCheck()) | |
| && "true".equalsIgnoreCase(modelPublisherAssertion.getToCheck())) { | |
| apiAssertionStatusItem.setCompletionStatus(CompletionStatus.STATUS_COMPLETE); | |
| } else if (!"true".equalsIgnoreCase(modelPublisherAssertion.getFromCheck()) | |
| && "true".equalsIgnoreCase(modelPublisherAssertion.getToCheck())) { | |
| apiAssertionStatusItem.setCompletionStatus(CompletionStatus.STATUS_FROM_KEY_INCOMPLETE); | |
| } else if ("true".equalsIgnoreCase(modelPublisherAssertion.getFromCheck()) | |
| && !"true".equalsIgnoreCase(modelPublisherAssertion.getToCheck())) { | |
| apiAssertionStatusItem.setCompletionStatus(CompletionStatus.STATUS_TO_KEY_INCOMPLETE); | |
| } else if (!"true".equalsIgnoreCase(modelPublisherAssertion.getFromCheck()) | |
| && !"true".equalsIgnoreCase(modelPublisherAssertion.getToCheck())) { | |
| apiAssertionStatusItem.setCompletionStatus(CompletionStatus.STATUS_BOTH_INCOMPLETE); | |
| } | |
| org.uddi.api_v3.KeysOwned keysOwned = new org.uddi.api_v3.KeysOwned(); | |
| //converting resultList to simple List | |
| List<String> businessKeyList = new ArrayList<String>(); | |
| for (Object businessKey : businessKeys) { | |
| businessKeyList.add(String.valueOf(businessKey)); | |
| } | |
| Collections.sort(businessKeyList); | |
| if (Collections.binarySearch(businessKeyList, modelPublisherAssertion.getBusinessEntityByFromKey().getEntityKey()) >= 0) { | |
| keysOwned.setFromKey(modelPublisherAssertion.getBusinessEntityByFromKey().getEntityKey()); | |
| } | |
| if (Collections.binarySearch(businessKeyList, modelPublisherAssertion.getBusinessEntityByToKey().getEntityKey()) >= 0) { | |
| keysOwned.setToKey(modelPublisherAssertion.getBusinessEntityByToKey().getEntityKey()); | |
| } | |
| if (keysOwned.getFromKey() == null && keysOwned.getToKey() == null) { | |
| throw new FatalErrorException(new ErrorMessage("errors.invalidKey.KeysOwned")); | |
| } | |
| apiAssertionStatusItem.setKeysOwned(keysOwned); | |
| } | |
| public static void mapRelatedBusinessInfo(org.apache.juddi.model.PublisherAssertion modelPublisherAssertion, | |
| org.apache.juddi.model.BusinessEntity modelRelatedBusiness, | |
| org.uddi.api_v3.Direction direction, | |
| org.uddi.api_v3.RelatedBusinessInfo apiRelatedBusinessInfo) | |
| throws DispositionReportFaultMessage { | |
| apiRelatedBusinessInfo.setBusinessKey(modelRelatedBusiness.getEntityKey()); | |
| mapBusinessNames(modelRelatedBusiness.getBusinessNames(), apiRelatedBusinessInfo.getName()); | |
| mapBusinessDescriptions(modelRelatedBusiness.getBusinessDescrs(), apiRelatedBusinessInfo.getDescription()); | |
| org.uddi.api_v3.SharedRelationships sharedRelationships = new org.uddi.api_v3.SharedRelationships(); | |
| sharedRelationships.setDirection(direction); | |
| org.uddi.api_v3.KeyedReference keyedRef = new org.uddi.api_v3.KeyedReference(); | |
| keyedRef.setTModelKey(modelPublisherAssertion.getTmodelKey()); | |
| keyedRef.setKeyName(modelPublisherAssertion.getKeyName()); | |
| keyedRef.setKeyValue(modelPublisherAssertion.getKeyValue()); | |
| sharedRelationships.getKeyedReference().add(keyedRef); | |
| apiRelatedBusinessInfo.getSharedRelationships().add(sharedRelationships); | |
| } | |
| public static void mapOperationalInfo(UddiEntity modelUddiEntity, | |
| OperationalInfo apiOperationalInfo) | |
| throws DispositionReportFaultMessage { | |
| apiOperationalInfo.setCreated(TypeConvertor.convertDateToXMLGregorianCalendar(modelUddiEntity.getCreated())); | |
| apiOperationalInfo.setModified(TypeConvertor.convertDateToXMLGregorianCalendar(modelUddiEntity.getModified())); | |
| apiOperationalInfo.setModifiedIncludingChildren(TypeConvertor.convertDateToXMLGregorianCalendar(modelUddiEntity.getModifiedIncludingChildren())); | |
| apiOperationalInfo.setNodeID(modelUddiEntity.getNodeId()); | |
| apiOperationalInfo.setAuthorizedName(modelUddiEntity.getAuthorizedName()); | |
| apiOperationalInfo.setEntityKey(modelUddiEntity.getEntityKey()); | |
| } | |
| public static void mapSubscription(org.apache.juddi.model.Subscription modelSubscription, | |
| org.uddi.sub_v3.Subscription apiSubscription) | |
| throws DispositionReportFaultMessage { | |
| apiSubscription.setSubscriptionKey(modelSubscription.getSubscriptionKey()); | |
| apiSubscription.setBrief(modelSubscription.isBrief()); | |
| apiSubscription.setExpiresAfter(TypeConvertor.convertDateToXMLGregorianCalendar(modelSubscription.getExpiresAfter())); | |
| apiSubscription.setBindingKey(modelSubscription.getBindingKey()); | |
| apiSubscription.setMaxEntities(modelSubscription.getMaxEntities()); | |
| apiSubscription.setNotificationInterval(TypeConvertor.convertStringToDuration(modelSubscription.getNotificationInterval())); | |
| try { | |
| SubscriptionFilter existingFilter = (SubscriptionFilter) JAXBMarshaller.unmarshallFromString(modelSubscription.getSubscriptionFilter(), JAXBMarshaller.PACKAGE_SUBSCRIPTION); | |
| apiSubscription.setSubscriptionFilter(existingFilter); | |
| } catch (JAXBException e) { | |
| logger.error("JAXB Exception while marshalling subscription filter", e); | |
| throw new FatalErrorException(new ErrorMessage("errors.Unspecified")); | |
| } | |
| } | |
| public static void mapClientSubscriptionInfo(org.apache.juddi.model.ClientSubscriptionInfo modelClientSubscriptionInfo, | |
| org.apache.juddi.api_v3.ClientSubscriptionInfo apiClientSubscriptionInfo, EntityManager em) | |
| throws DispositionReportFaultMessage { | |
| apiClientSubscriptionInfo.setSubscriptionKey(modelClientSubscriptionInfo.getSubscriptionKey()); | |
| GregorianCalendar gcal = new GregorianCalendar(); | |
| gcal.setTimeInMillis(modelClientSubscriptionInfo.getLastNotified().getTime()); | |
| try { | |
| apiClientSubscriptionInfo.setLastModified(DatatypeFactory.newInstance().newXMLGregorianCalendar(gcal)); | |
| } catch (DatatypeConfigurationException ex) { | |
| logger.warn("unable to create DatatypeFactory", ex); | |
| } | |
| if (modelClientSubscriptionInfo.getFromClerk() != null) { | |
| org.apache.juddi.api_v3.Clerk apiFromClerk = new org.apache.juddi.api_v3.Clerk(); | |
| mapClerk(modelClientSubscriptionInfo.getFromClerk(), apiFromClerk,em); | |
| apiClientSubscriptionInfo.setFromClerk(apiFromClerk); | |
| } | |
| if (modelClientSubscriptionInfo.getToClerk() != null) { | |
| org.apache.juddi.api_v3.Clerk apiToClerk = new org.apache.juddi.api_v3.Clerk(); | |
| mapClerk(modelClientSubscriptionInfo.getToClerk(), apiToClerk,em); | |
| apiClientSubscriptionInfo.setToClerk(apiToClerk); | |
| } | |
| } | |
| public static void mapClerk(org.apache.juddi.model.Clerk modelClerk, | |
| org.apache.juddi.api_v3.Clerk apiClerk,EntityManager em) | |
| throws DispositionReportFaultMessage { | |
| apiClerk.setName(modelClerk.getClerkName()); | |
| apiClerk.setPassword(modelClerk.getCred()); | |
| apiClerk.setPublisher(modelClerk.getPublisherId()); | |
| if (modelClerk.getNode() != null) { | |
| org.apache.juddi.api_v3.Node apiNode = new org.apache.juddi.api_v3.Node(); | |
| mapNode( | |
| em.find(org.apache.juddi.model.Node.class, modelClerk.getNode()) | |
| , apiNode); | |
| apiClerk.setNode(apiNode); | |
| } | |
| } | |
| public static void mapNode(org.apache.juddi.model.Node modelNode, | |
| org.apache.juddi.api_v3.Node apiNode) | |
| throws DispositionReportFaultMessage { | |
| apiNode.setCustodyTransferUrl(modelNode.getCustodyTransferUrl()); | |
| apiNode.setFactoryInitial(modelNode.getFactoryInitial()); | |
| apiNode.setFactoryNamingProvider(modelNode.getFactoryNamingProvider()); | |
| apiNode.setFactoryURLPkgs(modelNode.getFactoryURLPkgs()); | |
| apiNode.setInquiryUrl(modelNode.getInquiryUrl()); | |
| apiNode.setJuddiApiUrl(modelNode.getJuddiApiUrl()); | |
| apiNode.setName(modelNode.getName()); | |
| apiNode.setClientName(modelNode.getClientName()); | |
| apiNode.setProxyTransport(modelNode.getProxyTransport()); | |
| apiNode.setPublishUrl(modelNode.getPublishUrl()); | |
| apiNode.setSecurityUrl(modelNode.getSecurityUrl()); | |
| apiNode.setSubscriptionUrl(modelNode.getSubscriptionUrl()); | |
| apiNode.setSubscriptionListenerUrl(modelNode.getSubscriptionListenerUrl()); | |
| apiNode.setReplicationUrl(modelNode.getReplicationUrl()); | |
| } | |
| private static Object convertDataToTransformContent(String type, byte[] xformBytes) throws RuntimeException { | |
| Object transformObject; | |
| if (type.equals(String.class.getSimpleName())) { | |
| try { | |
| transformObject = new String(xformBytes, "UTF-8"); | |
| } catch (Exception e) { | |
| throw new RuntimeException("Error decoding string due to: " + e.getMessage(), e); | |
| } | |
| } else if (type.equals(byte[].class.getSimpleName())) { | |
| transformObject = xformBytes; | |
| } else if (type.equals(Element.class.getCanonicalName())) { | |
| DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); | |
| try { | |
| dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); | |
| dbf.setNamespaceAware(true); | |
| dbf.setXIncludeAware(true); | |
| DocumentBuilder db = dbf.newDocumentBuilder(); | |
| Document doc = db.parse(new ByteArrayInputStream(xformBytes)); | |
| transformObject = doc.getDocumentElement(); | |
| } catch (Exception e) { | |
| throw new RuntimeException("Failed to parse element due to: " + e.getMessage(), e); | |
| } | |
| } else { | |
| throw new RuntimeException("Unrecognized type: " + type); | |
| } | |
| return transformObject; | |
| } | |
| public static void mapReplicationConfiguration(ReplicationConfiguration find, org.uddi.repl_v3.ReplicationConfiguration item) throws DispositionReportFaultMessage { | |
| item.setMaximumTimeToGetChanges(find.getMaximumTimeToGetChanges()); | |
| item.setMaximumTimeToSyncRegistry(find.getMaximumTimeToSyncRegistry()); | |
| item.setSerialNumber(find.getSerialNumber()); | |
| List<SignatureType> sigs = new ArrayList<SignatureType>(); | |
| mapSignature(find.getSignatures(), sigs); | |
| item.getSignature().addAll(sigs); | |
| mapOperator(find.getOperator(), item.getOperator()); | |
| List<org.apache.juddi.model.Contact> modelContactList = new ArrayList<org.apache.juddi.model.Contact>(); | |
| org.uddi.api_v3.Contacts cs = new Contacts(); | |
| mapContacts(modelContactList, cs, new BusinessEntity()); | |
| item.setRegistryContact(new org.uddi.repl_v3.ReplicationConfiguration.RegistryContact()); | |
| if (!cs.getContact().isEmpty()) { | |
| item.getRegistryContact().setContact(cs.getContact().get(0)); | |
| } | |
| else | |
| { | |
| item.getRegistryContact().setContact(new Contact()); | |
| item.getRegistryContact().getContact().getPersonName().add(new PersonName("unknown", null)); | |
| } | |
| item.setTimeOfConfigurationUpdate(find.getTimeOfConfigurationUpdate()); | |
| CommunicationGraph xcom = new CommunicationGraph(); | |
| mapCommunicationGraph(find, xcom); | |
| item.setCommunicationGraph(xcom); | |
| //(List<org.apache.juddi.model.Contact> modelContactList, | |
| //org.uddi.api_v3.Contacts apiContacts, | |
| //org.uddi.api_v3.BusinessEntity apiBusinessEntity) | |
| } | |
| private static void mapOperator(List<org.apache.juddi.model.Operator> model, List<Operator> api) throws DispositionReportFaultMessage { | |
| for (int i = 0; i < model.size(); i++) { | |
| Operator op = new Operator(); | |
| op.setOperatorNodeID(model.get(i).getOperatorNodeID()); | |
| op.setSoapReplicationURL(model.get(i).getSoapReplicationURL()); | |
| switch (model.get(i).getOperatorStatus()) { | |
| case NEW: | |
| op.setOperatorStatus(OperatorStatusType.NEW); | |
| break; | |
| case NORMAL: | |
| op.setOperatorStatus(OperatorStatusType.NORMAL); | |
| break; | |
| case RESIGNED: | |
| op.setOperatorStatus(OperatorStatusType.RESIGNED); | |
| break; | |
| } | |
| Contacts c = new Contacts(); | |
| mapContacts(model.get(i).getContact(), c, new BusinessEntity()); | |
| op.getContact().addAll(c.getContact()); | |
| if (model.get(i).getKeyInfo() != null) { | |
| for (int x = 0; x < model.get(i).getKeyInfo().size(); x++) { | |
| KeyInfoType apiKeyInfo = new KeyInfoType(); | |
| KeyInfo modelKeyInfo = model.get(i).getKeyInfo().get(x); | |
| apiKeyInfo.setId(modelKeyInfo.getXmlID()); | |
| List<KeyDataValue> modelKeyDataValueList = modelKeyInfo.getKeyDataValue(); | |
| List<Object> apiX509KeyInfoList = apiKeyInfo.getContent(); | |
| mapModelKeyDataValue(modelKeyDataValueList, apiX509KeyInfoList); | |
| op.getKeyInfo().add(apiKeyInfo); | |
| } | |
| } | |
| api.add(op); | |
| } | |
| } | |
| private static void mapCommunicationGraph(org.apache.juddi.model.ReplicationConfiguration model, | |
| CommunicationGraph api) { | |
| mapEdge(model.getEdge(), api.getEdge()); | |
| mapControlMessages(model.getControlMessage(), api.getControlledMessage()); | |
| mapEdgeNodes(model.getNode(), api.getNode()); | |
| } | |
| private static void mapEdge(List<Edge> model, List<CommunicationGraph.Edge> api) { | |
| Iterator<Edge> it = model.iterator(); | |
| while (it.hasNext()) { | |
| Edge modelEdge = it.next(); | |
| CommunicationGraph.Edge apiEdge = new CommunicationGraph.Edge(); | |
| apiEdge.setMessageReceiver(modelEdge.getMessageReceiver()); | |
| apiEdge.setMessageSender(modelEdge.getMessageSender()); | |
| Iterator<ControlMessage> it2 = modelEdge.getMessages().iterator(); | |
| while (it2.hasNext()) { | |
| apiEdge.getMessage().add(it2.next().getMessage()); | |
| } | |
| Iterator<EdgeReceiverAlternate> it3 = modelEdge.getMessageReceiverAlternate().iterator(); | |
| while (it3.hasNext()) { | |
| apiEdge.getMessageReceiverAlternate().add(it3.next().getReceiverAlternate()); | |
| } | |
| api.add(apiEdge); | |
| } | |
| } | |
| private static void mapControlMessages(List<ControlMessage> model, List<String> api) { | |
| Iterator<ControlMessage> it = model.iterator(); | |
| while (it.hasNext()) { | |
| api.add(it.next().getMessage()); | |
| } | |
| } | |
| private static void mapEdgeNodes(List<ReplicationConfigurationNode> model, List<String> api) { | |
| Iterator<ReplicationConfigurationNode> it = model.iterator(); | |
| while (it.hasNext()) { | |
| api.add(it.next().getNodeName()); | |
| } | |
| } | |
| public static ChangeRecord mapChangeRecord(org.apache.juddi.model.ChangeRecord cr) { | |
| if (cr == null) { | |
| return null; | |
| } | |
| ChangeRecord ret = null; | |
| StringReader sr = null; | |
| try { | |
| sr = new StringReader(new String(cr.getContents(), "UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| Logger.getLogger(MappingModelToApi.class.getName()).log(Level.SEVERE, null, ex); | |
| } | |
| ret = (ChangeRecord) XmlUtils.unmarshal(sr, ChangeRecord.class); | |
| //secret sauce here, if this is -1, that means that the record originated at this node and needs to be populated with the databases record id | |
| if (cr.getOriginatingUSN() == null || cr.getOriginatingUSN() == -1L) { | |
| ret.setChangeID(new ChangeRecordIDType(cr.getNodeID(), cr.getId())); | |
| } else { | |
| ret.setChangeID(new ChangeRecordIDType(cr.getNodeID(), cr.getOriginatingUSN())); | |
| } | |
| return ret; | |
| } | |
| } |