Commit 503b40ff authored by Kostis Trantzas's avatar Kostis Trantzas
Browse files

Merge branch... 

Merge branch '83-implement-the-listener-api-for-product-catalog-620-with-just-stub-code' into 'develop'

Resolve "Implement the Listener API for product catalog 620 with just stub code"

See merge request !79
parents 144699d7 3bbfb4df

pom.xml

+8 −0
Original line number Diff line number Diff line
@@ -449,6 +449,14 @@ 
                	<parallel>none</parallel>

                	<runOrder>alphabetical</runOrder>

                	<forkCount>1</forkCount>

                	<reuseForks>false</reuseForks>

                	    <!--

					    <argLine>-Xmx2g -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=${project.build.directory}/heap.hprof</argLine>

					    <systemPropertyVariables>

					      <spring.test.context.cache.maxSize>8</spring.test.context.cache.maxSize>

					      <logging.level.org.springframework.test.context.cache>TRACE</logging.level.org.springframework.test.context.cache>

					    </systemPropertyVariables>

          			-->

            	</configuration>

			</plugin>

			<plugin>

src/main/java/org/etsi/osl/tmf/pcm620/api/HubApi.java

+27 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ import org.springframework.web.bind.annotation.PathVariable; 
import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

import io.swagger.v3.oas.annotations.Operation;

import io.swagger.v3.oas.annotations.Parameter;

import io.swagger.v3.oas.annotations.responses.ApiResponse;
@@ -116,4 +117,30 @@ public interface HubApi { 
        return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

    }



    @Operation(summary = "Get all registered listeners", operationId = "getListeners", description = "Retrieves all registered event subscriptions", tags={ "events subscription", })

    @ApiResponses(value = { 

        @ApiResponse(responseCode = "200", description = "Success" ),

        @ApiResponse(responseCode = "400", description = "Bad Request" ),

        @ApiResponse(responseCode = "401", description = "Unauthorized" ),

        @ApiResponse(responseCode = "403", description = "Forbidden" ),

        @ApiResponse(responseCode = "500", description = "Internal Server Error" ) })

    @RequestMapping(value = "/hub",

        produces = { "application/json;charset=utf-8" },

        method = RequestMethod.GET)

    default ResponseEntity<List<EventSubscription>> getListeners() {

        if(getObjectMapper().isPresent() && getAcceptHeader().isPresent()) {

            if (getAcceptHeader().get().contains("application/json")) {

                try {

                    return new ResponseEntity<>(getObjectMapper().get().readValue("[ {  \"query\" : \"query\",  \"callback\" : \"callback\",  \"id\" : \"id\"} ]", List.class), HttpStatus.NOT_IMPLEMENTED);

                } catch (IOException e) {

                    log.error("Couldn't serialize response for content type application/json", e);

                    return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

                }

            }

        } else {

            log.warn("ObjectMapper or HttpServletRequest not configured in default HubApi interface so no example is generated");

        }

        return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

    }



}

src/main/java/org/etsi/osl/tmf/pcm620/api/HubApiController.java

+20 −2
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
 */

package org.etsi.osl.tmf.pcm620.api;



import java.util.List;

import java.util.Optional;



import com.fasterxml.jackson.databind.ObjectMapper;
@@ -35,6 +36,7 @@ import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;



import io.swagger.v3.oas.annotations.Parameter;

import jakarta.servlet.http.HttpServletRequest;
@@ -70,8 +72,11 @@ public class HubApiController implements HubApi { 
        return Optional.ofNullable(request);

    }



    /* 

     * to register another OSL for example use   "callback": "http://localhost:13082/tmf-api/productCatalogManagement/v4/"

     */

    @Override

    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN')")

    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")

    public ResponseEntity<EventSubscription> registerListener(@Parameter(description = "Data containing the callback endpoint to deliver the information", required = true) @Valid @RequestBody EventSubscriptionInput data) {

        try {

            EventSubscription eventSubscription = eventSubscriptionRepoService.addEventSubscription(data);
@@ -86,7 +91,8 @@ public class HubApiController implements HubApi { 
    }



    @Override

    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN')")

    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")

    @RequestMapping(value = "/hub/{id}", method = RequestMethod.DELETE, produces = { "application/json;charset=utf-8" })

    public ResponseEntity<Void> unregisterListener(@Parameter(description = "The id of the registered listener", required = true) @PathVariable("id") String id) {

        try {

            EventSubscription existing = eventSubscriptionRepoService.findById(id);
@@ -102,4 +108,16 @@ public class HubApiController implements HubApi { 
        }

    }



    @Override

    @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_USER')")

    public ResponseEntity<List<EventSubscription>> getListeners() {

        try {

            List<EventSubscription> eventSubscriptions = eventSubscriptionRepoService.findAll();

            return new ResponseEntity<>(eventSubscriptions, HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error retrieving listeners", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



}

src/main/java/org/etsi/osl/tmf/pcm620/api/ListenerApiController.java

+205 −1
Original line number Diff line number Diff line
@@ -22,17 +22,41 @@ package org.etsi.osl.tmf.pcm620.api; 
import java.util.Optional;



import com.fasterxml.jackson.databind.ObjectMapper;



import org.etsi.osl.tmf.pcm620.model.CatalogBatchEvent;

import org.etsi.osl.tmf.pcm620.model.CatalogCreateEvent;

import org.etsi.osl.tmf.pcm620.model.CatalogDeleteEvent;

import org.etsi.osl.tmf.pcm620.model.CategoryCreateEvent;

import org.etsi.osl.tmf.pcm620.model.CategoryDeleteEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingAttributeValueChangeEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingCreateEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingDeleteEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceAttributeValueChangeEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceCreateEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceDeleteEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceStateChangeEvent;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingStateChangeEvent;

import org.etsi.osl.tmf.pcm620.model.ProductSpecificationCreateEvent;

import org.etsi.osl.tmf.pcm620.model.ProductSpecificationDeleteEvent;

import org.etsi.osl.tmf.pcm620.model.EventSubscription;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;



import io.swagger.v3.oas.annotations.Parameter;

import jakarta.servlet.http.HttpServletRequest;

import jakarta.validation.Valid;

@jakarta.annotation.Generated(value = "io.swagger.codegen.languages.SpringCodegen", date = "2019-10-19T00:15:57.249+03:00")



@Controller("ListenerApiController620")

@RequestMapping("/productCatalogManagement/v4/")

public class ListenerApiController implements ListenerApi {



    private static final Logger log = LoggerFactory.getLogger(ListenerApiController.class);



    private final ObjectMapper objectMapper;



    private final HttpServletRequest request;
@@ -53,4 +77,184 @@ public class ListenerApiController implements ListenerApi { 
        return Optional.ofNullable(request);

    }



    @Override

    public ResponseEntity<EventSubscription> listenToCatalogBatchEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogBatchEvent data) {

        try {

            log.info("Received CatalogBatchEvent: {}", data.getEventId());

            log.debug("CatalogBatchEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing CatalogBatchEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToCatalogCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogCreateEvent data) {

        try {

            log.info("Received CatalogCreateEvent: {}", data.getEventId());

            log.debug("CatalogCreateEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing CatalogCreateEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToCatalogDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CatalogDeleteEvent data) {

        try {

            log.info("Received CatalogDeleteEvent: {}", data.getEventId());

            log.debug("CatalogDeleteEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing CatalogDeleteEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToCategoryCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CategoryCreateEvent data) {

        try {

            log.info("Received CategoryCreateEvent: {}", data.getEventId());

            log.debug("CategoryCreateEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing CategoryCreateEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToCategoryDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody CategoryDeleteEvent data) {

        try {

            log.info("Received CategoryDeleteEvent: {}", data.getEventId());

            log.debug("CategoryDeleteEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing CategoryDeleteEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingAttributeValueChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingAttributeValueChangeEvent data) {

        try {

            log.info("Received ProductOfferingAttributeValueChangeEvent: {}", data.getEventId());

            log.debug("ProductOfferingAttributeValueChangeEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingAttributeValueChangeEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingCreateEvent data) {

        try {

            log.info("Received ProductOfferingCreateEvent: {}", data.getEventId());

            log.debug("ProductOfferingCreateEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingCreateEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingDeleteEvent data) {

        try {

            log.info("Received ProductOfferingDeleteEvent: {}", data.getEventId());

            log.debug("ProductOfferingDeleteEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingDeleteEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingPriceAttributeValueChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceAttributeValueChangeEvent data) {

        try {

            log.info("Received ProductOfferingPriceAttributeValueChangeEvent: {}", data.getEventId());

            log.debug("ProductOfferingPriceAttributeValueChangeEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingPriceAttributeValueChangeEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingPriceCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceCreateEvent data) {

        try {

            log.info("Received ProductOfferingPriceCreateEvent: {}", data.getEventId());

            log.debug("ProductOfferingPriceCreateEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingPriceCreateEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingPriceDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceDeleteEvent data) {

        try {

            log.info("Received ProductOfferingPriceDeleteEvent: {}", data.getEventId());

            log.debug("ProductOfferingPriceDeleteEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingPriceDeleteEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingPriceStateChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingPriceStateChangeEvent data) {

        try {

            log.info("Received ProductOfferingPriceStateChangeEvent: {}", data.getEventId());

            log.debug("ProductOfferingPriceStateChangeEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingPriceStateChangeEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductOfferingStateChangeEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductOfferingStateChangeEvent data) {

        try {

            log.info("Received ProductOfferingStateChangeEvent: {}", data.getEventId());

            log.debug("ProductOfferingStateChangeEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductOfferingStateChangeEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductSpecificationCreateEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductSpecificationCreateEvent data) {

        try {

            log.info("Received ProductSpecificationCreateEvent: {}", data.getEventId());

            log.debug("ProductSpecificationCreateEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductSpecificationCreateEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<EventSubscription> listenToProductSpecificationDeleteEvent(@Parameter(description = "The event data", required = true) @Valid @RequestBody ProductSpecificationDeleteEvent data) {

        try {

            log.info("Received ProductSpecificationDeleteEvent: {}", data.getEventId());

            log.debug("ProductSpecificationDeleteEvent details: {}", data);

            return new ResponseEntity<>(HttpStatus.OK);

        } catch (Exception e) {

            log.error("Error processing ProductSpecificationDeleteEvent", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



}

src/main/java/org/etsi/osl/tmf/pcm620/api/ProductCatalogApiRouteBuilderEvents.java

0 → 100644
+189 −0
Original line number Diff line number Diff line 
/*-

 * ========================LICENSE_START=================================

 * org.etsi.osl.tmf.api

 * %%

 * Copyright (C) 2019 - 2020 openslice.io

 * %%

 * 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.

 * =========================LICENSE_END==================================

 */

package org.etsi.osl.tmf.pcm620.api;



import java.io.IOException;

import java.util.HashMap;

import java.util.Map;



import com.fasterxml.jackson.annotation.JsonInclude;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;



import org.apache.camel.ProducerTemplate;

import org.apache.camel.builder.RouteBuilder;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.etsi.osl.centrallog.client.CLevel;

import org.etsi.osl.centrallog.client.CentralLogger;

import org.etsi.osl.tmf.common.model.Notification;

import org.etsi.osl.tmf.pcm620.model.CatalogCreateNotification;

import org.etsi.osl.tmf.pcm620.model.CatalogDeleteNotification;

import org.etsi.osl.tmf.pcm620.model.CategoryCreateNotification;

import org.etsi.osl.tmf.pcm620.model.CategoryDeleteNotification;

import org.etsi.osl.tmf.pcm620.model.ProductSpecificationCreateNotification;

import org.etsi.osl.tmf.pcm620.model.ProductSpecificationDeleteNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingCreateNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingDeleteNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingAttributeValueChangeNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingStateChangeNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceCreateNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceDeleteNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceAttributeValueChangeNotification;

import org.etsi.osl.tmf.pcm620.model.ProductOfferingPriceStateChangeNotification;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Configuration;

import org.springframework.stereotype.Component;

import org.springframework.transaction.annotation.Transactional;



@Configuration

@Component

public class ProductCatalogApiRouteBuilderEvents extends RouteBuilder {



	private static final transient Log logger = LogFactory.getLog(ProductCatalogApiRouteBuilderEvents.class.getName());



	@Value("${EVENT_PRODUCT_CATALOG_CREATE}")

	private String EVENT_CATALOG_CREATE = "";

	

	@Value("${EVENT_PRODUCT_CATALOG_DELETE}")

	private String EVENT_CATALOG_DELETE = "";

	

	@Value("${EVENT_PRODUCT_CATEGORY_CREATE}")

	private String EVENT_CATEGORY_CREATE = "";

	

	@Value("${EVENT_PRODUCT_CATEGORY_DELETE}")

	private String EVENT_CATEGORY_DELETE = "";

	

	@Value("${EVENT_PRODUCT_SPECIFICATION_CREATE}")

	private String EVENT_PRODUCT_SPECIFICATION_CREATE = "";

	

	@Value("${EVENT_PRODUCT_SPECIFICATION_DELETE}")

	private String EVENT_PRODUCT_SPECIFICATION_DELETE  = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_CREATE}")

	private String EVENT_PRODUCT_OFFERING_CREATE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_DELETE}")

	private String EVENT_PRODUCT_OFFERING_DELETE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_ATTRIBUTE_VALUE_CHANGE}")

	private String EVENT_PRODUCT_OFFERING_ATTRIBUTE_VALUE_CHANGE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_STATE_CHANGE}")

	private String EVENT_PRODUCT_OFFERING_STATE_CHANGE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_PRICE_CREATE}")

	private String EVENT_PRODUCT_OFFERING_PRICE_CREATE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_PRICE_DELETE}")

	private String EVENT_PRODUCT_OFFERING_PRICE_DELETE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_PRICE_ATTRIBUTE_VALUE_CHANGE}")

	private String EVENT_PRODUCT_OFFERING_PRICE_ATTRIBUTE_VALUE_CHANGE = "";

	

	@Value("${EVENT_PRODUCT_OFFERING_PRICE_STATE_CHANGE}")

	private String EVENT_PRODUCT_OFFERING_PRICE_STATE_CHANGE = "";



	@Value("${spring.application.name}")

	private String compname;

	

	@Autowired

	private ProducerTemplate template;



	@Autowired

	private CentralLogger centralLogger;



	@Override

	public void configure() throws Exception {

		// Configure routes for catalog events

	}



	/**

	 * Publish notification events for catalog operations

	 * @param n The notification to publish

	 * @param objId The catalog object ID

	 */

    @Transactional

	public void publishEvent(final Notification n, final String objId) {

		n.setEventType(n.getClass().getName());

		logger.info("will send Event for type " + n.getEventType());

		try {

			String msgtopic = "";

			

			if (n instanceof CatalogCreateNotification) {

				 msgtopic = EVENT_CATALOG_CREATE;

			} else if (n instanceof CatalogDeleteNotification) {

				 msgtopic = EVENT_CATALOG_DELETE;

			} else if (n instanceof CategoryCreateNotification) {

				 msgtopic = EVENT_CATEGORY_CREATE;

			} else if (n instanceof CategoryDeleteNotification) {

				 msgtopic = EVENT_CATEGORY_DELETE;

			} else if (n instanceof ProductSpecificationCreateNotification) {

				 msgtopic = EVENT_PRODUCT_SPECIFICATION_CREATE;

			} else if (n instanceof ProductSpecificationDeleteNotification) {

				 msgtopic = EVENT_PRODUCT_SPECIFICATION_DELETE;

			} else if (n instanceof ProductOfferingCreateNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_CREATE;

			} else if (n instanceof ProductOfferingDeleteNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_DELETE;

			} else if (n instanceof ProductOfferingAttributeValueChangeNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_ATTRIBUTE_VALUE_CHANGE;

			} else if (n instanceof ProductOfferingStateChangeNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_STATE_CHANGE;

			} else if (n instanceof ProductOfferingPriceCreateNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_PRICE_CREATE;

			} else if (n instanceof ProductOfferingPriceDeleteNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_PRICE_DELETE;

			} else if (n instanceof ProductOfferingPriceAttributeValueChangeNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_PRICE_ATTRIBUTE_VALUE_CHANGE;

			} else if (n instanceof ProductOfferingPriceStateChangeNotification) {

				 msgtopic = EVENT_PRODUCT_OFFERING_PRICE_STATE_CHANGE;

			}

			

			Map<String, Object> map = new HashMap<>();

			map.put("eventid", n.getEventId());

			map.put("objId", objId);

			

			String apayload = toJsonString(n);

			template.sendBodyAndHeaders(msgtopic, apayload, map);

			

			centralLogger.log(CLevel.INFO, apayload, compname);	



		} catch (Exception e) {

			e.printStackTrace();

			logger.error("Cannot send Event . " + e.getMessage());

		}

	}



	static String toJsonString(Object object) throws IOException {

		ObjectMapper mapper = new ObjectMapper();

		mapper.registerModule(new JavaTimeModule());

		mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

		return mapper.writeValueAsString(object);

	}



	static <T> T toJsonObj(String content, Class<T> valueType) throws IOException {

        ObjectMapper mapper = new ObjectMapper();

        mapper.registerModule(new JavaTimeModule());

        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        return mapper.readValue(content, valueType);

    }

}
 
 No newline at end of file