| /* | |
| * 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.api.impl; | |
| import java.io.StringWriter; | |
| import java.io.UnsupportedEncodingException; | |
| import java.util.ArrayList; | |
| import java.util.Date; | |
| import java.util.GregorianCalendar; | |
| import java.util.List; | |
| import javax.jws.WebService; | |
| import javax.persistence.EntityManager; | |
| import javax.persistence.EntityTransaction; | |
| import javax.persistence.Query; | |
| import javax.xml.bind.JAXB; | |
| import javax.xml.datatype.DatatypeConfigurationException; | |
| import javax.xml.datatype.DatatypeFactory; | |
| import javax.xml.ws.Holder; | |
| import org.apache.commons.configuration.ConfigurationException; | |
| import org.apache.commons.logging.Log; | |
| import org.apache.commons.logging.LogFactory; | |
| import org.apache.juddi.api.util.PublicationQuery; | |
| import org.apache.juddi.api.util.QueryStatus; | |
| import org.apache.juddi.config.AppConfig; | |
| import org.apache.juddi.config.PersistenceManager; | |
| import org.apache.juddi.config.Property; | |
| import org.apache.juddi.mapping.MappingApiToModel; | |
| import org.apache.juddi.mapping.MappingModelToApi; | |
| import org.apache.juddi.model.BindingTemplate; | |
| import org.apache.juddi.model.BusinessEntity; | |
| import org.apache.juddi.model.BusinessService; | |
| import org.apache.juddi.model.ChangeRecord; | |
| import org.apache.juddi.model.Signature; | |
| import org.apache.juddi.model.Tmodel; | |
| import org.apache.juddi.model.UddiEntityPublisher; | |
| import org.apache.juddi.query.FetchBusinessEntitiesQuery; | |
| import org.apache.juddi.query.FetchTModelsQuery; | |
| import org.apache.juddi.query.FindBusinessByPublisherQuery; | |
| import org.apache.juddi.query.FindPublisherAssertionByBusinessQuery; | |
| import org.apache.juddi.query.FindTModelByPublisherQuery; | |
| import org.apache.juddi.query.TModelQuery; | |
| import org.apache.juddi.query.util.DynamicQuery; | |
| import org.apache.juddi.query.util.FindQualifiers; | |
| import org.apache.juddi.replication.ReplicationNotifier; | |
| import org.apache.juddi.v3.error.ErrorMessage; | |
| import org.apache.juddi.v3.error.FatalErrorException; | |
| import org.apache.juddi.v3.error.InvalidValueException; | |
| import org.apache.juddi.validation.ValidatePublish; | |
| import org.uddi.api_v3.AddPublisherAssertions; | |
| import org.uddi.api_v3.AssertionStatusItem; | |
| import org.uddi.api_v3.BindingDetail; | |
| import org.uddi.api_v3.BusinessDetail; | |
| import org.uddi.api_v3.CompletionStatus; | |
| import org.uddi.api_v3.DeleteBinding; | |
| import org.uddi.api_v3.DeleteBusiness; | |
| import org.uddi.api_v3.DeletePublisherAssertions; | |
| import org.uddi.api_v3.DeleteService; | |
| import org.uddi.api_v3.DeleteTModel; | |
| import org.uddi.api_v3.GetRegisteredInfo; | |
| import org.uddi.api_v3.InfoSelection; | |
| import org.uddi.api_v3.ListDescription; | |
| import org.uddi.api_v3.OperationalInfo; | |
| import org.uddi.api_v3.PublisherAssertion; | |
| import org.uddi.api_v3.RegisteredInfo; | |
| import org.uddi.api_v3.SaveBinding; | |
| import org.uddi.api_v3.SaveBusiness; | |
| import org.uddi.api_v3.SaveService; | |
| import org.uddi.api_v3.SaveTModel; | |
| import org.uddi.api_v3.ServiceDetail; | |
| import org.uddi.api_v3.TModel; | |
| import org.uddi.api_v3.TModelDetail; | |
| import org.uddi.repl_v3.ChangeRecordDelete; | |
| import org.uddi.repl_v3.ChangeRecordDeleteAssertion; | |
| import org.uddi.repl_v3.ChangeRecordHide; | |
| import org.uddi.repl_v3.ChangeRecordIDType; | |
| import org.uddi.repl_v3.ChangeRecordNewData; | |
| import org.uddi.repl_v3.ChangeRecordNewDataConditional; | |
| import org.uddi.repl_v3.ChangeRecordPublisherAssertion; | |
| import org.uddi.v3_service.DispositionReportFaultMessage; | |
| import org.uddi.v3_service.UDDIPublicationPortType; | |
| /** | |
| * This class implements the UDDI Publication Service | |
| * | |
| * @author <a href="mailto:jfaath@apache.org">Jeff Faath</a> (and many others) | |
| * @author <a href="mailto:alexoree@apache.org">Alex O'Ree</a> added support for | |
| * replication and several bug fixes | |
| */ | |
| @WebService(serviceName = "UDDIPublicationService", | |
| endpointInterface = "org.uddi.v3_service.UDDIPublicationPortType", | |
| targetNamespace = "urn:uddi-org:api_v3_portType") | |
| public class UDDIPublicationImpl extends AuthenticatedService implements UDDIPublicationPortType { | |
| private static Log log = LogFactory.getLog(UDDIInquiryImpl.class); | |
| private UDDIServiceCounter serviceCounter; | |
| public UDDIPublicationImpl() { | |
| super(); | |
| serviceCounter = ServiceCounterLifecycleResource.getServiceCounter(UDDIPublicationImpl.class); | |
| } | |
| @Override | |
| public void addPublisherAssertions(AddPublisherAssertions body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateAddPublisherAssertions(em, body); | |
| List<org.uddi.api_v3.PublisherAssertion> apiPubAssertionList = body.getPublisherAssertion(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.PublisherAssertion apiPubAssertion : apiPubAssertionList) { | |
| org.apache.juddi.model.PublisherAssertion modelPubAssertion = new org.apache.juddi.model.PublisherAssertion(); | |
| MappingApiToModel.mapPublisherAssertion(apiPubAssertion, modelPubAssertion); | |
| org.apache.juddi.model.PublisherAssertion existingPubAssertion = em.find(modelPubAssertion.getClass(), modelPubAssertion.getId()); | |
| boolean persistNewAssertion = true; | |
| if (existingPubAssertion != null) { | |
| if (modelPubAssertion.getTmodelKey().equalsIgnoreCase(existingPubAssertion.getTmodelKey()) | |
| && modelPubAssertion.getKeyName().equalsIgnoreCase(existingPubAssertion.getKeyName()) | |
| && modelPubAssertion.getKeyValue().equalsIgnoreCase(existingPubAssertion.getKeyValue())) { | |
| // This pub assertion is already been "asserted". Simply need to set the "check" value on the existing (and persistent) assertion | |
| if (publisher.isOwner(existingPubAssertion.getBusinessEntityByFromKey())) { | |
| existingPubAssertion.setFromCheck("true"); | |
| } | |
| if (publisher.isOwner(existingPubAssertion.getBusinessEntityByToKey())) { | |
| existingPubAssertion.setToCheck("true"); | |
| } | |
| //it's also possible that the signatures have changed | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| savePushliserAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), modelPubAssertion.getSignatures(), em); | |
| em.merge(existingPubAssertion); | |
| persistNewAssertion = false; | |
| changes.add(getChangeRecord_deletePublisherAssertion(apiPubAssertion, getNode(), existingPubAssertion.getToCheck().equalsIgnoreCase("false"), existingPubAssertion.getFromCheck().equalsIgnoreCase("false"), System.currentTimeMillis())); | |
| } else { | |
| // Otherwise, it is a new relationship between these entities. Remove the old one so the new one can be added. | |
| // TODO: the model only seems to allow one assertion per two business (primary key is fromKey and toKey). Spec seems to imply as | |
| // many relationships as desired (the differentiator would be the keyedRef values). | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| em.remove(existingPubAssertion); | |
| changes.add(getChangeRecord_deletePublisherAssertion(apiPubAssertion, getNode(), true, true, System.currentTimeMillis())); | |
| } | |
| } | |
| if (persistNewAssertion) { | |
| org.apache.juddi.model.BusinessEntity beFrom = em.find(org.apache.juddi.model.BusinessEntity.class, modelPubAssertion.getId().getFromKey()); | |
| org.apache.juddi.model.BusinessEntity beTo = em.find(org.apache.juddi.model.BusinessEntity.class, modelPubAssertion.getId().getToKey()); | |
| modelPubAssertion.setBusinessEntityByFromKey(beFrom); | |
| modelPubAssertion.setBusinessEntityByToKey(beTo); | |
| modelPubAssertion.setFromCheck("false"); | |
| modelPubAssertion.setToCheck("false"); | |
| if (publisher.isOwner(modelPubAssertion.getBusinessEntityByFromKey())) { | |
| modelPubAssertion.setFromCheck("true"); | |
| } | |
| if (publisher.isOwner(modelPubAssertion.getBusinessEntityByToKey())) { | |
| modelPubAssertion.setToCheck("true"); | |
| } | |
| modelPubAssertion.setModified(new Date()); | |
| savePushliserAssertionSignatures(modelPubAssertion.getBusinessEntityByFromKey().getEntityKey(), modelPubAssertion.getBusinessEntityByToKey().getEntityKey(), modelPubAssertion.getSignatures(), em); | |
| em.persist(modelPubAssertion); | |
| changes.add(getChangeRecord_NewAssertion(apiPubAssertion, modelPubAssertion, getNode())); | |
| } | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.ADD_PUBLISHERASSERTIONS, | |
| QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.ADD_PUBLISHERASSERTIONS, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| @Override | |
| public void deleteBinding(DeleteBinding body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateDeleteBinding(em, body); | |
| List<String> entityKeyList = body.getBindingKey(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (String entityKey : entityKeyList) { | |
| deleteBinding(entityKey, em); | |
| changes.add(getChangeRecord_deleteBinding(entityKey, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_BINDING, | |
| QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_BINDING, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * deletes the referenced object, assuming authorization rules are | |
| * already processed and there is already an open transaction | |
| * | |
| * @param entityKey | |
| * @param em | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| protected void deleteBinding(String entityKey, EntityManager em) throws DispositionReportFaultMessage { | |
| Object obj = em.find(org.apache.juddi.model.BindingTemplate.class, entityKey); | |
| ((org.apache.juddi.model.BindingTemplate) obj).getBusinessService().setModifiedIncludingChildren(new Date()); | |
| // JUDDI-421: now the businessEntity parent will have it's modifiedIncludingChildren set | |
| ((org.apache.juddi.model.BindingTemplate) obj).getBusinessService().getBusinessEntity().setModifiedIncludingChildren(new Date()); | |
| em.remove(obj); | |
| } | |
| @Override | |
| public void deleteBusiness(DeleteBusiness body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateDeleteBusiness(em, body); | |
| List<String> entityKeyList = body.getBusinessKey(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (String entityKey : entityKeyList) { | |
| deleteBusiness(entityKey, em); | |
| changes.add(getChangeRecord_deleteBusiness(entityKey, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_BUSINESS, QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_BUSINESS, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * deletes the referenced object, assuming authorization rules are | |
| * already processed and there is already an open transaction | |
| * | |
| * @param entityKey | |
| * @param em | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| protected void deleteBusiness(String key, EntityManager em) throws DispositionReportFaultMessage { | |
| Object obj = em.find(org.apache.juddi.model.BusinessEntity.class, key); | |
| em.remove(obj); | |
| } | |
| @Override | |
| public void deletePublisherAssertions(DeletePublisherAssertions body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateDeletePublisherAssertions(em, body); | |
| List<org.uddi.api_v3.PublisherAssertion> entityList = body.getPublisherAssertion(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.PublisherAssertion entity : entityList) { | |
| org.apache.juddi.model.PublisherAssertion modelPubAssertion = new org.apache.juddi.model.PublisherAssertion(); | |
| MappingApiToModel.mapPublisherAssertion(entity, modelPubAssertion); | |
| org.apache.juddi.model.PublisherAssertion existingPubAssertion = em.find(org.apache.juddi.model.PublisherAssertion.class, | |
| modelPubAssertion.getId()); | |
| if (existingPubAssertion == null) { | |
| throw new InvalidValueException(new ErrorMessage("E_assertionNotFound")); | |
| } | |
| boolean fromkey = publisher.isOwner(em.find(BusinessEntity.class, entity.getFromKey())); | |
| boolean tokey = publisher.isOwner(em.find(BusinessEntity.class, entity.getToKey())); | |
| if (fromkey) { | |
| existingPubAssertion.setFromCheck("false"); | |
| } | |
| if (tokey) { | |
| existingPubAssertion.setToCheck("false"); | |
| } | |
| if ("false".equalsIgnoreCase(existingPubAssertion.getToCheck()) | |
| && "false".equalsIgnoreCase(existingPubAssertion.getFromCheck())) { | |
| logger.info("Publisher assertion updated database via replication"); | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| em.remove(existingPubAssertion); | |
| } else { | |
| existingPubAssertion.setModified(new Date()); | |
| logger.info("Publisher assertion updated database via replication"); | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| savePushliserAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), | |
| existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), modelPubAssertion.getSignatures(), em); | |
| em.persist(existingPubAssertion); | |
| } | |
| changes.add(getChangeRecord_deletePublisherAssertion(entity, getNode(), tokey, fromkey, existingPubAssertion.getModified().getTime())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_PUBLISHERASSERTIONS, | |
| QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_PUBLISHERASSERTIONS, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * deletes the referenced object, assuming authorization rules are | |
| * already processed and there is already an open transaction. this is | |
| * primarily used to support replication calls, i.e. another node just | |
| * changed a PA record and let us know | |
| * | |
| * @param entityKey | |
| * @param em | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| protected void deletePublisherAssertion(org.uddi.repl_v3.ChangeRecordDeleteAssertion entity, EntityManager em) throws DispositionReportFaultMessage { | |
| org.apache.juddi.model.PublisherAssertion modelPubAssertion = new org.apache.juddi.model.PublisherAssertion(); | |
| MappingApiToModel.mapPublisherAssertion(entity.getPublisherAssertion(), modelPubAssertion); | |
| org.apache.juddi.model.PublisherAssertion existingPubAssertion = em.find(org.apache.juddi.model.PublisherAssertion.class, | |
| modelPubAssertion.getId()); | |
| if (existingPubAssertion == null) { | |
| throw new FatalErrorException(new ErrorMessage("E_assertionNotFound")); | |
| } | |
| boolean fromkey = entity.isFromBusinessCheck();// publisher.isOwner(em.find(BusinessEntity.class, entity.getFromKey())); | |
| boolean tokey = entity.isToBusinessCheck();// publisher.isOwner(em.find(BusinessEntity.class, entity.getToKey())); | |
| if (fromkey) { | |
| existingPubAssertion.setFromCheck("false"); | |
| } | |
| if (tokey) { | |
| existingPubAssertion.setToCheck("false"); | |
| } | |
| if ("false".equalsIgnoreCase(existingPubAssertion.getToCheck()) | |
| && "false".equalsIgnoreCase(existingPubAssertion.getFromCheck())) { | |
| logger.info("Deletion of publisher assertion from database via replication"); | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| em.remove(existingPubAssertion); | |
| } else { | |
| existingPubAssertion.setModified(new Date()); | |
| logger.info("Publisher assertion updated database via replication"); | |
| removeExistingPublisherAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), em); | |
| savePushliserAssertionSignatures(existingPubAssertion.getBusinessEntityByFromKey().getEntityKey(), | |
| existingPubAssertion.getBusinessEntityByToKey().getEntityKey(), modelPubAssertion.getSignatures(), em); | |
| em.persist(existingPubAssertion); | |
| } | |
| } | |
| @Override | |
| public void deleteService(DeleteService body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateDeleteService(em, body); | |
| List<String> entityKeyList = body.getServiceKey(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (String entityKey : entityKeyList) { | |
| deleteService(entityKey, em); | |
| changes.add(getChangeRecord_deleteService(entityKey, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_SERVICE, | |
| QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_SERVICE, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * deletes the referenced object, assuming authorization rules are | |
| * already processed and there is already an open transaction | |
| * | |
| * @param entityKey | |
| * @param em | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| protected void deleteService(String key, EntityManager em) throws DispositionReportFaultMessage { | |
| Object obj = em.find(org.apache.juddi.model.BusinessService.class, key); | |
| //((org.apache.juddi.model.BusinessService) obj).getBusinessEntity().setModifiedIncludingChildren(new Date()); | |
| if (obj != null) { | |
| em.remove(obj); | |
| } else { | |
| logger.warn("Unable to remove service with the key '" + key + "', it doesn't exist in the database"); | |
| } | |
| } | |
| /** | |
| * {@inheritDoc } | |
| */ | |
| @Override | |
| public void deleteTModel(DeleteTModel body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateDeleteTModel(em, body); | |
| // tModels are only lazily deleted! | |
| List<String> entityKeyList = body.getTModelKey(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (String entityKey : entityKeyList) { | |
| deleteTModel(entityKey, em); | |
| changes.add(getChangeRecord_deleteTModelHide(entityKey, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_TMODEL, QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.DELETE_TMODEL, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * deletes the referenced object, assuming authorization rules are | |
| * already processed and there is already an open transaction | |
| * | |
| * @param entityKey | |
| * @param em | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| protected void deleteTModel(String key, EntityManager em) { | |
| Object obj = em.find(org.apache.juddi.model.Tmodel.class, key); | |
| ((org.apache.juddi.model.Tmodel) obj).setDeleted(true); | |
| } | |
| /** | |
| * {@inheritDoc } | |
| */ | |
| @Override | |
| public List<AssertionStatusItem> getAssertionStatusReport(String authInfo, | |
| CompletionStatus completionStatus) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, authInfo); | |
| List<org.uddi.api_v3.AssertionStatusItem> result = PublicationHelper.getAssertionStatusItemList(publisher, completionStatus, em); | |
| tx.commit(); | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_ASSERTIONSTATUSREPORT, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_ASSERTIONSTATUSREPORT, QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| public List<PublisherAssertion> getPublisherAssertions(String authInfo) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, authInfo); | |
| List<org.uddi.api_v3.PublisherAssertion> result = new ArrayList<org.uddi.api_v3.PublisherAssertion>(0); | |
| List<?> businessKeysFound = null; | |
| businessKeysFound = FindBusinessByPublisherQuery.select(em, null, publisher, businessKeysFound); | |
| List<org.apache.juddi.model.PublisherAssertion> pubAssertionList = FindPublisherAssertionByBusinessQuery.select(em, businessKeysFound, null); | |
| if (pubAssertionList != null) { | |
| for (org.apache.juddi.model.PublisherAssertion modelPubAssertion : pubAssertionList) { | |
| org.uddi.api_v3.PublisherAssertion apiPubAssertion = new org.uddi.api_v3.PublisherAssertion(); | |
| MappingModelToApi.mapPublisherAssertion(modelPubAssertion, apiPubAssertion); | |
| result.add(apiPubAssertion); | |
| } | |
| } | |
| tx.commit(); | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_PUBLISHERASSERTIONS, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_PUBLISHERASSERTIONS, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| * @throws org.uddi.v3_service.DispositionReportFaultMessage | |
| */ | |
| @Override | |
| public RegisteredInfo getRegisteredInfo(GetRegisteredInfo body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| new ValidatePublish(publisher,ctx).validateRegisteredInfo(body); | |
| List<?> businessKeysFound = null; | |
| businessKeysFound = FindBusinessByPublisherQuery.select(em, null, publisher, businessKeysFound); | |
| List<?> tmodelKeysFound = null; | |
| if (body.getInfoSelection().equals(InfoSelection.HIDDEN)) { | |
| tmodelKeysFound = FindTModelByPublisherQuery.select(em, null, publisher, tmodelKeysFound, new DynamicQuery.Parameter(TModelQuery.ENTITY_ALIAS + ".deleted", Boolean.TRUE, DynamicQuery.PREDICATE_EQUALS)); | |
| } else if (body.getInfoSelection().equals(InfoSelection.VISIBLE)) { | |
| tmodelKeysFound = FindTModelByPublisherQuery.select(em, null, publisher, tmodelKeysFound, new DynamicQuery.Parameter(TModelQuery.ENTITY_ALIAS + ".deleted", Boolean.FALSE, DynamicQuery.PREDICATE_EQUALS)); | |
| } else { | |
| tmodelKeysFound = FindTModelByPublisherQuery.select(em, null, publisher, tmodelKeysFound); | |
| } | |
| RegisteredInfo result = new RegisteredInfo(); | |
| // Sort and retrieve the final results | |
| List<?> queryResults = FetchBusinessEntitiesQuery.select(em, new FindQualifiers(), businessKeysFound, null, null, null); | |
| if (queryResults.size() > 0) { | |
| result.setBusinessInfos(new org.uddi.api_v3.BusinessInfos()); | |
| for (Object item : queryResults) { | |
| org.apache.juddi.model.BusinessEntity modelBusinessEntity = (org.apache.juddi.model.BusinessEntity) item; | |
| org.uddi.api_v3.BusinessInfo apiBusinessInfo = new org.uddi.api_v3.BusinessInfo(); | |
| MappingModelToApi.mapBusinessInfo(modelBusinessEntity, apiBusinessInfo); | |
| result.getBusinessInfos().getBusinessInfo().add(apiBusinessInfo); | |
| } | |
| } | |
| // Sort and retrieve the final results | |
| queryResults = FetchTModelsQuery.select(em, new FindQualifiers(), tmodelKeysFound, null, null, null); | |
| if (queryResults.size() > 0) { | |
| result.setTModelInfos(new org.uddi.api_v3.TModelInfos()); | |
| for (Object item : queryResults) { | |
| org.apache.juddi.model.Tmodel modelTModel = (org.apache.juddi.model.Tmodel) item; | |
| org.uddi.api_v3.TModelInfo apiTModelInfo = new org.uddi.api_v3.TModelInfo(); | |
| MappingModelToApi.mapTModelInfo(modelTModel, apiTModelInfo); | |
| result.getTModelInfos().getTModelInfo().add(apiTModelInfo); | |
| } | |
| } | |
| tx.commit(); | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_REGISTEREDINFO, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.GET_REGISTEREDINFO, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| * @throws org.uddi.v3_service.DispositionReportFaultMessage | |
| */ | |
| @Override | |
| public BindingDetail saveBinding(SaveBinding body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| publisher.populateKeyGeneratorKeys(em); | |
| ValidatePublish validator = new ValidatePublish(publisher,ctx); | |
| validator.validateSaveBinding(em, body, null, publisher); | |
| BindingDetail result = new BindingDetail(); | |
| result.setListDescription(new ListDescription()); | |
| List<org.uddi.api_v3.BindingTemplate> apiBindingTemplateList = body.getBindingTemplate(); | |
| List<org.apache.juddi.model.ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.BindingTemplate apiBindingTemplate : apiBindingTemplateList) { | |
| org.apache.juddi.model.BindingTemplate modelBindingTemplate = new org.apache.juddi.model.BindingTemplate(); | |
| org.apache.juddi.model.BusinessService modelBusinessService = new org.apache.juddi.model.BusinessService(); | |
| modelBusinessService.setEntityKey(apiBindingTemplate.getServiceKey()); | |
| MappingApiToModel.mapBindingTemplate(apiBindingTemplate, modelBindingTemplate, modelBusinessService); | |
| setOperationalInfo(em, modelBindingTemplate, publisher, true); | |
| em.persist(modelBindingTemplate); | |
| result.getBindingTemplate().add(apiBindingTemplate); | |
| result.getListDescription().setActualCount(result.getListDescription().getActualCount() + 1); | |
| result.getListDescription().setIncludeCount(result.getListDescription().getIncludeCount() + 1); | |
| validator.validateSaveBindingMax(em, modelBindingTemplate.getBusinessService().getEntityKey()); | |
| changes.add(getChangeRecord(modelBindingTemplate, apiBindingTemplate, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_BINDING, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_BINDING, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| * @throws org.uddi.v3_service.DispositionReportFaultMessage | |
| */ | |
| @Override | |
| public BusinessDetail saveBusiness(SaveBusiness body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| publisher.populateKeyGeneratorKeys(em); | |
| ValidatePublish validator = new ValidatePublish(publisher,ctx); | |
| validator.validateSaveBusiness(em, body, null, publisher); | |
| BusinessDetail result = new BusinessDetail(); | |
| List<org.uddi.api_v3.BusinessEntity> apiBusinessEntityList = body.getBusinessEntity(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.BusinessEntity apiBusinessEntity : apiBusinessEntityList) { | |
| org.apache.juddi.model.BusinessEntity modelBusinessEntity = new org.apache.juddi.model.BusinessEntity(); | |
| MappingApiToModel.mapBusinessEntity(apiBusinessEntity, modelBusinessEntity); | |
| setOperationalInfo(em, modelBusinessEntity, publisher); | |
| log.debug("Saving business " + modelBusinessEntity.getEntityKey()); | |
| em.persist(modelBusinessEntity); | |
| changes.add(getChangeRecord(modelBusinessEntity, apiBusinessEntity, getNode())); | |
| result.getBusinessEntity().add(apiBusinessEntity); | |
| } | |
| //check how many business this publisher owns. | |
| validator.validateSaveBusinessMax(em); | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_BUSINESS, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_BUSINESS, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } catch (Exception ex) { | |
| StringWriter sw = new StringWriter(); | |
| if (body != null) { | |
| JAXB.marshal(body, sw); | |
| } | |
| log.fatal("unexpected error!" + sw.toString(), ex); | |
| throw new FatalErrorException(new ErrorMessage("E_fatalError", ex.getMessage())); | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| */ | |
| public ServiceDetail saveService(SaveService body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| publisher.populateKeyGeneratorKeys(em); | |
| ValidatePublish validator = new ValidatePublish(publisher,ctx); | |
| validator.validateSaveService(em, body, null, publisher); | |
| ServiceDetail result = new ServiceDetail(); | |
| List<org.uddi.api_v3.BusinessService> apiBusinessServiceList = body.getBusinessService(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.BusinessService apiBusinessService : apiBusinessServiceList) { | |
| org.apache.juddi.model.BusinessService modelBusinessService = new org.apache.juddi.model.BusinessService(); | |
| org.apache.juddi.model.BusinessEntity modelBusinessEntity = new org.apache.juddi.model.BusinessEntity(); | |
| modelBusinessEntity.setEntityKey(apiBusinessService.getBusinessKey()); | |
| MappingApiToModel.mapBusinessService(apiBusinessService, modelBusinessService, modelBusinessEntity); | |
| setOperationalInfo(em, modelBusinessService, publisher, false); | |
| em.persist(modelBusinessService); | |
| result.getBusinessService().add(apiBusinessService); | |
| validator.validateSaveServiceMax(em, modelBusinessService.getBusinessEntity().getEntityKey()); | |
| changes.add(getChangeRecord(modelBusinessService, apiBusinessService, getNode())); | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_SERVICE, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_SERVICE, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| */ | |
| @Override | |
| public TModelDetail saveTModel(SaveTModel body) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, body.getAuthInfo()); | |
| publisher.populateKeyGeneratorKeys(em); | |
| new ValidatePublish(publisher,ctx).validateSaveTModel(em, body, null, publisher); | |
| TModelDetail result = new TModelDetail(); | |
| List<org.uddi.api_v3.TModel> apiTModelList = body.getTModel(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| for (org.uddi.api_v3.TModel apiTModel : apiTModelList) { | |
| // Object obj=em.find( org.apache.juddi.model.Tmodel.class, apiTModel.getTModelKey()); | |
| //just making changes to an existing tModel, no worries | |
| org.apache.juddi.model.Tmodel modelTModel = new org.apache.juddi.model.Tmodel(); | |
| MappingApiToModel.mapTModel(apiTModel, modelTModel); | |
| setOperationalInfo(em, modelTModel, publisher); | |
| em.persist(modelTModel); | |
| result.getTModel().add(apiTModel); | |
| changes.add(getChangeRecord(modelTModel, apiTModel, getNode())); | |
| /* | |
| //TODO JUDDI-915 | |
| if (obj != null) { | |
| changes.add(getChangeRecord(modelTModel, apiTModel, node)); | |
| } else { | |
| //special case for replication, must setup a new data conditional change record | |
| changes.add(getChangeRecordConditional(modelTModel, apiTModel, node)); | |
| }*/ | |
| } | |
| tx.commit(); | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_TMODEL, | |
| QueryStatus.SUCCESS, procTime); | |
| return result; | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SAVE_TMODEL, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| */ | |
| @Override | |
| public void setPublisherAssertions(String authInfo, | |
| Holder<List<PublisherAssertion>> publisherAssertion) | |
| throws DispositionReportFaultMessage { | |
| long startTime = System.currentTimeMillis(); | |
| EntityManager em = PersistenceManager.getEntityManager(); | |
| EntityTransaction tx = em.getTransaction(); | |
| List<ChangeRecord> changes = new ArrayList<ChangeRecord>(); | |
| try { | |
| tx.begin(); | |
| UddiEntityPublisher publisher = this.getEntityPublisher(em, authInfo); | |
| new ValidatePublish(publisher,ctx).validateSetPublisherAssertions(em, publisherAssertion); | |
| List<?> businessKeysFound = null; | |
| businessKeysFound = FindBusinessByPublisherQuery.select(em, null, publisher, businessKeysFound); | |
| //TODO this has to be reworked to record what was deleted. | |
| // First, identify all previous assertions that need to be removed | |
| List<org.apache.juddi.model.PublisherAssertion> existingAssertions = FindPublisherAssertionByBusinessQuery.select(em, businessKeysFound, null); | |
| logger.debug(">>>> Existing assertions " + existingAssertions.size() + ", inbound set " + publisherAssertion.value.size()); | |
| List<org.apache.juddi.model.PublisherAssertion> deleteMe = diff(publisherAssertion.value, existingAssertions); | |
| logger.debug(">>>> DIFF size is " + deleteMe.size()); | |
| for (org.apache.juddi.model.PublisherAssertion del : deleteMe) { | |
| logger.debug(">>>> PROCESSING " + del.getBusinessEntityByFromKey().getEntityKey() + " " + del.getBusinessEntityByToKey().getEntityKey()); | |
| boolean from = false; | |
| if (del.getFromCheck() != null) { | |
| del.getFromCheck().equalsIgnoreCase("true"); | |
| } | |
| boolean to = false; | |
| if (del.getToCheck() != null) { | |
| del.getToCheck().equalsIgnoreCase("true"); | |
| } | |
| if (publisher.isOwner(del.getBusinessEntityByFromKey())) { | |
| from = false; | |
| } | |
| if (publisher.isOwner(del.getBusinessEntityByToKey())) { | |
| to = false; | |
| } | |
| PublisherAssertion api = new PublisherAssertion(); | |
| MappingModelToApi.mapPublisherAssertion(del, api); | |
| if (!to && !from) { | |
| logger.debug(">>>> DELETE ME " + del.getBusinessEntityByFromKey().getEntityKey() + " " + del.getBusinessEntityByToKey().getEntityKey()); | |
| em.remove(del); | |
| } else { | |
| logger.debug(">>>> MERGING ME " + del.getBusinessEntityByFromKey().getEntityKey() + " " + del.getBusinessEntityByToKey().getEntityKey()); | |
| del.setFromCheck(from ? "true" : "false"); | |
| del.setToCheck(to ? "true" : "false"); | |
| del.setModified(new Date()); | |
| em.merge(del); | |
| } | |
| changes.add(getChangeRecord_deletePublisherAssertion(api, getNode(), to, from, System.currentTimeMillis())); | |
| } | |
| //DeletePublisherAssertionByBusinessQuery.delete(em, businessKeysFound); | |
| // Slate is clean for all assertions involving this publisher, now we simply need to add the new ones (and they will all be "new"). | |
| /*List<org.uddi.api_v3.PublisherAssertion> apiPubAssertionList = publisherAssertion.value; | |
| for (org.uddi.api_v3.PublisherAssertion apiPubAssertion : apiPubAssertionList) { | |
| org.apache.juddi.model.PublisherAssertion modelPubAssertion = new org.apache.juddi.model.PublisherAssertion(); | |
| MappingApiToModel.mapPublisherAssertion(apiPubAssertion, modelPubAssertion); | |
| org.apache.juddi.model.BusinessEntity beFrom = em.find(org.apache.juddi.model.BusinessEntity.class, modelPubAssertion.getId().getFromKey()); | |
| org.apache.juddi.model.BusinessEntity beTo = em.find(org.apache.juddi.model.BusinessEntity.class, modelPubAssertion.getId().getToKey()); | |
| modelPubAssertion.setBusinessEntityByFromKey(beFrom); | |
| modelPubAssertion.setBusinessEntityByToKey(beTo); | |
| modelPubAssertion.setFromCheck("false"); | |
| modelPubAssertion.setToCheck("false"); | |
| if (publisher.isOwner(modelPubAssertion.getBusinessEntityByFromKey())) { | |
| modelPubAssertion.setFromCheck("true"); | |
| } | |
| if (publisher.isOwner(modelPubAssertion.getBusinessEntityByToKey())) { | |
| modelPubAssertion.setToCheck("true"); | |
| } | |
| em.persist(modelPubAssertion); | |
| changes.add(getChangeRecord_NewAssertion(apiPubAssertion, modelPubAssertion, node)); | |
| }*/ | |
| tx.commit(); | |
| if (!publisherAssertion.value.isEmpty()) { | |
| AddPublisherAssertions addPublisherAssertions = new AddPublisherAssertions(); | |
| addPublisherAssertions.setAuthInfo(authInfo); | |
| addPublisherAssertions.getPublisherAssertion().addAll(publisherAssertion.value); | |
| addPublisherAssertions(addPublisherAssertions); | |
| } | |
| for (int i = 0; i < changes.size(); i++) { | |
| ReplicationNotifier.enqueue(changes.get(i)); | |
| } | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SET_PUBLISHERASSERTIONS, | |
| QueryStatus.SUCCESS, procTime); | |
| } catch (DispositionReportFaultMessage drfm) { | |
| long procTime = System.currentTimeMillis() - startTime; | |
| serviceCounter.update(PublicationQuery.SET_PUBLISHERASSERTIONS, | |
| QueryStatus.FAILED, procTime); | |
| throw drfm; | |
| } finally { | |
| if (tx.isActive()) { | |
| tx.rollback(); | |
| } | |
| em.close(); | |
| } | |
| } | |
| private void setOperationalInfo(EntityManager em, org.apache.juddi.model.BusinessEntity uddiEntity, UddiEntityPublisher publisher) throws DispositionReportFaultMessage { | |
| uddiEntity.setAuthorizedName(publisher.getAuthorizedName()); | |
| Date now = new Date(); | |
| uddiEntity.setModified(now); | |
| uddiEntity.setModifiedIncludingChildren(now); | |
| String nodeId = ""; | |
| try { | |
| nodeId = AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID); | |
| } catch (ConfigurationException ce) { | |
| throw new FatalErrorException(new ErrorMessage("errors.configuration.Retrieval", Property.JUDDI_NODE_ID)); | |
| } | |
| uddiEntity.setNodeId(nodeId); | |
| org.apache.juddi.model.BusinessEntity existingUddiEntity = em.find(uddiEntity.getClass(), uddiEntity.getEntityKey()); | |
| if (existingUddiEntity != null) { | |
| uddiEntity.setCreated(existingUddiEntity.getCreated()); | |
| } else { | |
| uddiEntity.setCreated(now); | |
| } | |
| List<org.apache.juddi.model.BusinessService> serviceList = uddiEntity.getBusinessServices(); | |
| for (org.apache.juddi.model.BusinessService service : serviceList) { | |
| setOperationalInfo(em, service, publisher, true); | |
| } | |
| if (existingUddiEntity != null) { | |
| em.remove(existingUddiEntity); | |
| } | |
| } | |
| private void setOperationalInfo(EntityManager em, org.apache.juddi.model.BusinessService uddiEntity, UddiEntityPublisher publisher, boolean isChild) throws DispositionReportFaultMessage { | |
| uddiEntity.setAuthorizedName(publisher.getAuthorizedName()); | |
| Date now = new Date(); | |
| uddiEntity.setModified(now); | |
| uddiEntity.setModifiedIncludingChildren(now); | |
| if (!isChild) { | |
| org.apache.juddi.model.BusinessEntity parent = em.find(org.apache.juddi.model.BusinessEntity.class, uddiEntity.getBusinessEntity().getEntityKey()); | |
| parent.setModifiedIncludingChildren(now); | |
| em.persist(parent); | |
| } | |
| String nodeId = ""; | |
| try { | |
| nodeId = AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID); | |
| } catch (ConfigurationException ce) { | |
| throw new FatalErrorException(new ErrorMessage("errors.configuration.Retrieval", Property.JUDDI_NODE_ID)); | |
| } | |
| uddiEntity.setNodeId(nodeId); | |
| org.apache.juddi.model.BusinessService existingUddiEntity = em.find(uddiEntity.getClass(), uddiEntity.getEntityKey()); | |
| if (existingUddiEntity != null) { | |
| uddiEntity.setCreated(existingUddiEntity.getCreated()); | |
| } else { | |
| uddiEntity.setCreated(now); | |
| } | |
| List<org.apache.juddi.model.BindingTemplate> bindingList = uddiEntity.getBindingTemplates(); | |
| for (org.apache.juddi.model.BindingTemplate binding : bindingList) { | |
| setOperationalInfo(em, binding, publisher, true); | |
| } | |
| if (existingUddiEntity != null) { | |
| em.remove(existingUddiEntity); | |
| } | |
| } | |
| private void setOperationalInfo(EntityManager em, org.apache.juddi.model.BindingTemplate uddiEntity, UddiEntityPublisher publisher, boolean isChild) throws DispositionReportFaultMessage { | |
| uddiEntity.setAuthorizedName(publisher.getAuthorizedName()); | |
| Date now = new Date(); | |
| uddiEntity.setModified(now); | |
| uddiEntity.setModifiedIncludingChildren(now); | |
| //if (!isChild) { | |
| org.apache.juddi.model.BusinessService parent = em.find(org.apache.juddi.model.BusinessService.class, uddiEntity.getBusinessService().getEntityKey()); | |
| if (parent != null) { | |
| parent.setModifiedIncludingChildren(now); | |
| em.persist(parent); | |
| // JUDDI-421: now the businessEntity parent will have it's modifiedIncludingChildren set | |
| org.apache.juddi.model.BusinessEntity businessParent = em.find(org.apache.juddi.model.BusinessEntity.class, parent.getBusinessEntity().getEntityKey()); | |
| if (businessParent != null) { | |
| businessParent.setModifiedIncludingChildren(now); | |
| em.persist(businessParent); | |
| } else { | |
| logger.debug("Parent business is null for saved binding template!"); | |
| } | |
| } else { | |
| logger.debug("Parent service is null for saved binding template!"); | |
| } | |
| // } | |
| String nodeId = ""; | |
| try { | |
| nodeId = AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID); | |
| } catch (ConfigurationException ce) { | |
| throw new FatalErrorException(new ErrorMessage("errors.configuration.Retrieval", Property.JUDDI_NODE_ID)); | |
| } | |
| uddiEntity.setNodeId(nodeId); | |
| org.apache.juddi.model.BindingTemplate existingUddiEntity = em.find(uddiEntity.getClass(), uddiEntity.getEntityKey()); | |
| if (existingUddiEntity != null) { | |
| uddiEntity.setCreated(existingUddiEntity.getCreated()); | |
| } else { | |
| uddiEntity.setCreated(now); | |
| } | |
| if (existingUddiEntity != null) { | |
| em.remove(existingUddiEntity); | |
| } | |
| } | |
| private void setOperationalInfo(EntityManager em, org.apache.juddi.model.Tmodel uddiEntity, UddiEntityPublisher publisher) throws DispositionReportFaultMessage { | |
| uddiEntity.setAuthorizedName(publisher.getAuthorizedName()); | |
| Date now = new Date(); | |
| uddiEntity.setModified(now); | |
| uddiEntity.setModifiedIncludingChildren(now); | |
| String nodeId = ""; | |
| try { | |
| nodeId = AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID); | |
| } catch (ConfigurationException ce) { | |
| throw new FatalErrorException(new ErrorMessage("errors.configuration.Retrieval", Property.JUDDI_NODE_ID)); | |
| } | |
| uddiEntity.setNodeId(nodeId); | |
| org.apache.juddi.model.Tmodel existingUddiEntity = em.find(uddiEntity.getClass(), uddiEntity.getEntityKey()); | |
| if (existingUddiEntity != null) { | |
| uddiEntity.setCreated(existingUddiEntity.getCreated()); | |
| } else { | |
| uddiEntity.setCreated(now); | |
| } | |
| if (existingUddiEntity != null) { | |
| em.remove(existingUddiEntity); | |
| } | |
| } | |
| public static ChangeRecord getChangeRecord(BindingTemplate modelBindingTemplate, org.uddi.api_v3.BindingTemplate api, String node) throws DispositionReportFaultMessage { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(modelBindingTemplate.getEntityKey()); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordNewData); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordNewData(new ChangeRecordNewData()); | |
| crapi.getChangeRecordNewData().setBindingTemplate(api); | |
| crapi.getChangeRecordNewData().setOperationalInfo(new OperationalInfo()); | |
| MappingModelToApi.mapOperationalInfo(modelBindingTemplate, crapi.getChangeRecordNewData().getOperationalInfo()); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public static ChangeRecord getChangeRecord(BusinessService model, org.uddi.api_v3.BusinessService api, String node) throws DispositionReportFaultMessage { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(model.getEntityKey()); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordNewData); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordNewData(new ChangeRecordNewData()); | |
| crapi.getChangeRecordNewData().setBusinessService(api); | |
| crapi.getChangeRecordNewData().setOperationalInfo(new OperationalInfo()); | |
| MappingModelToApi.mapOperationalInfo(model, crapi.getChangeRecordNewData().getOperationalInfo()); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public ChangeRecord getChangeRecord_deleteBusiness(String entityKey, String node) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(entityKey); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordDelete); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordDelete(new ChangeRecordDelete()); | |
| crapi.getChangeRecordDelete().setBusinessKey(entityKey); | |
| crapi.getChangeRecordDelete().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public ChangeRecord getChangeRecord_deleteService(String entityKey, String node) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(entityKey); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordDelete); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordDelete(new ChangeRecordDelete()); | |
| crapi.getChangeRecordDelete().setServiceKey(entityKey); | |
| crapi.getChangeRecordDelete().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| /** | |
| * this is for "hiding" a tmodel, not removing it entirely | |
| * | |
| * @param entityKey | |
| * @param node | |
| * @return | |
| */ | |
| public ChangeRecord getChangeRecord_deleteTModelHide(String entityKey, String node) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(entityKey); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordHide); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordHide(new ChangeRecordHide()); | |
| crapi.getChangeRecordHide().setTModelKey(entityKey); | |
| crapi.getChangeRecordHide().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| //JAXB.marshal(crapi, System.out); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| /** | |
| * this is for deleting a tmodel, not hiding it | |
| * | |
| * @param entityKey | |
| * @param node | |
| * @return | |
| */ | |
| public static ChangeRecord getChangeRecord_deleteTModelDelete(String entityKey, String node, DatatypeFactory df) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(entityKey); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordDelete); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordDelete(new ChangeRecordDelete()); | |
| crapi.getChangeRecordDelete().setTModelKey(entityKey); | |
| crapi.getChangeRecordDelete().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| //JAXB.marshal(crapi, System.out); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public static ChangeRecord getChangeRecord(BusinessEntity modelBusinessEntity, org.uddi.api_v3.BusinessEntity apiBusinessEntity, String node) throws DispositionReportFaultMessage { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(modelBusinessEntity.getEntityKey()); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordNewData); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordNewData(new ChangeRecordNewData()); | |
| crapi.getChangeRecordNewData().setBusinessEntity(apiBusinessEntity); | |
| crapi.getChangeRecordNewData().setOperationalInfo(new OperationalInfo()); | |
| MappingModelToApi.mapOperationalInfo(modelBusinessEntity, crapi.getChangeRecordNewData().getOperationalInfo()); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public static ChangeRecord getChangeRecord(Tmodel modelBusinessEntity, org.uddi.api_v3.TModel apiBusinessEntity, String node) throws DispositionReportFaultMessage { | |
| ChangeRecord cr = new ChangeRecord(); | |
| if (!apiBusinessEntity.getTModelKey().equals(modelBusinessEntity.getEntityKey())) { | |
| throw new FatalErrorException(new ErrorMessage("E_fatalError", "the model and api keys do not match when saving a tmodel!")); | |
| } | |
| cr.setEntityKey(modelBusinessEntity.getEntityKey()); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordNewData); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordNewData(new ChangeRecordNewData()); | |
| crapi.getChangeRecordNewData().setTModel(apiBusinessEntity); | |
| crapi.getChangeRecordNewData().getTModel().setTModelKey(modelBusinessEntity.getEntityKey()); | |
| crapi.getChangeRecordNewData().setOperationalInfo(new OperationalInfo()); | |
| MappingModelToApi.mapOperationalInfo(modelBusinessEntity, crapi.getChangeRecordNewData().getOperationalInfo()); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public ChangeRecord getChangeRecord_deleteBinding(String entityKey, String node) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setEntityKey(entityKey); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordDelete); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordDelete(new ChangeRecordDelete()); | |
| crapi.getChangeRecordDelete().setBindingKey(entityKey); | |
| crapi.getChangeRecordDelete().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public ChangeRecord getChangeRecord_deletePublisherAssertion(PublisherAssertion entity, String node, boolean ToBusinessDelete, boolean FromBusinessDelete, long timestamp) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordDeleteAssertion); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordDeleteAssertion(new ChangeRecordDeleteAssertion()); | |
| crapi.getChangeRecordDeleteAssertion().setPublisherAssertion(entity); | |
| crapi.getChangeRecordDeleteAssertion().setToBusinessCheck(ToBusinessDelete); | |
| crapi.getChangeRecordDeleteAssertion().setFromBusinessCheck(FromBusinessDelete); | |
| GregorianCalendar gcal = new GregorianCalendar(); | |
| gcal.setTimeInMillis(timestamp); | |
| crapi.getChangeRecordDeleteAssertion().setModified(df.newXMLGregorianCalendar(gcal)); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| public ChangeRecord getChangeRecord_NewAssertion(PublisherAssertion apiPubAssertion, org.apache.juddi.model.PublisherAssertion modelPubAssertion, String node) { | |
| ChangeRecord cr = new ChangeRecord(); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordPublisherAssertion); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordPublisherAssertion(new ChangeRecordPublisherAssertion()); | |
| crapi.getChangeRecordPublisherAssertion().setFromBusinessCheck(modelPubAssertion.getFromCheck().equalsIgnoreCase("true")); | |
| crapi.getChangeRecordPublisherAssertion().setToBusinessCheck(modelPubAssertion.getToCheck().equalsIgnoreCase("true")); | |
| crapi.getChangeRecordPublisherAssertion().setPublisherAssertion(apiPubAssertion); | |
| crapi.getChangeRecordPublisherAssertion().setModified(df.newXMLGregorianCalendar(new GregorianCalendar())); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| /** | |
| * | |
| * @param value keep these | |
| * @param existingAssertions return a list of these that are NOT in | |
| * 'value' | |
| * @return | |
| * @throws DispositionReportFaultMessage | |
| */ | |
| private List<org.apache.juddi.model.PublisherAssertion> diff(List<PublisherAssertion> value, List<org.apache.juddi.model.PublisherAssertion> existingAssertions) throws DispositionReportFaultMessage { | |
| List<org.apache.juddi.model.PublisherAssertion> ret = new ArrayList<org.apache.juddi.model.PublisherAssertion>(); | |
| if (value == null || value.isEmpty()) { | |
| return existingAssertions; | |
| } | |
| if (existingAssertions == null) { | |
| return new ArrayList<org.apache.juddi.model.PublisherAssertion>(); | |
| } | |
| for (org.apache.juddi.model.PublisherAssertion model : existingAssertions) { | |
| boolean found = false; | |
| for (PublisherAssertion paapi : value) { | |
| if (model.getBusinessEntityByFromKey().getEntityKey().equalsIgnoreCase(paapi.getFromKey()) | |
| && model.getBusinessEntityByToKey().getEntityKey().equalsIgnoreCase(paapi.getToKey()) | |
| && model.getKeyName().equals(paapi.getKeyedReference().getKeyName()) | |
| && model.getKeyValue().equals(paapi.getKeyedReference().getKeyValue()) | |
| && model.getTmodelKey().equalsIgnoreCase(paapi.getKeyedReference().getTModelKey())) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| if (!found) { | |
| ret.add(model); | |
| } | |
| } | |
| return ret; | |
| } | |
| private static ChangeRecord getChangeRecordConditional(Tmodel modelTModel, TModel apiTModel, String node) throws DispositionReportFaultMessage { | |
| ChangeRecord cr = new ChangeRecord(); | |
| if (!apiTModel.getTModelKey().equals(modelTModel.getEntityKey())) { | |
| throw new FatalErrorException(new ErrorMessage("E_fatalError", "the model and api keys do not match when saving a tmodel!")); | |
| } | |
| cr.setEntityKey(modelTModel.getEntityKey()); | |
| cr.setNodeID(node); | |
| cr.setRecordType(ChangeRecord.RecordType.ChangeRecordNewDataConditional); | |
| org.uddi.repl_v3.ChangeRecord crapi = new org.uddi.repl_v3.ChangeRecord(); | |
| crapi.setChangeID(new ChangeRecordIDType(node, -1L)); | |
| crapi.setChangeRecordNewDataConditional(new ChangeRecordNewDataConditional()); | |
| crapi.getChangeRecordNewDataConditional().setChangeRecordNewData(new ChangeRecordNewData()); | |
| crapi.getChangeRecordNewDataConditional().getChangeRecordNewData().setTModel(apiTModel); | |
| crapi.getChangeRecordNewDataConditional().getChangeRecordNewData().getTModel().setTModelKey(modelTModel.getEntityKey()); | |
| crapi.getChangeRecordNewDataConditional().getChangeRecordNewData().setOperationalInfo(new OperationalInfo()); | |
| MappingModelToApi.mapOperationalInfo(modelTModel, crapi.getChangeRecordNewDataConditional().getChangeRecordNewData().getOperationalInfo()); | |
| StringWriter sw = new StringWriter(); | |
| JAXB.marshal(crapi, sw); | |
| try { | |
| cr.setContents(sw.toString().getBytes("UTF8")); | |
| } catch (UnsupportedEncodingException ex) { | |
| logger.error(ex); | |
| } | |
| return cr; | |
| } | |
| private void removeExistingPublisherAssertionSignatures(String from, String to, EntityManager em) { | |
| Query createQuery = em.createQuery("delete from Signature pa where pa.publisherAssertionFromKey=:from and pa.publisherAssertionToKey=:to"); | |
| createQuery.setParameter("from", from); | |
| createQuery.setParameter("to", to); | |
| createQuery.executeUpdate(); | |
| } | |
| private void savePushliserAssertionSignatures(String from, String to, List<Signature> signatures, EntityManager em) { | |
| if (signatures == null) { | |
| return; | |
| } | |
| for (Signature s : signatures) { | |
| s.setPublisherAssertionFromKey(from); | |
| s.setPublisherAssertionToKey(to); | |
| em.persist(s); | |
| } | |
| } | |
| } |