catalog-dao/src/test/java/org/openecomp/sdc/be/resources/AuditingDaoTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.resources;
  22
  23 import fj.data.Either;
  24 import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
  25 import org.elasticsearch.action.search.SearchResponse;
  26 import org.elasticsearch.index.query.MatchAllQueryBuilder;
  27 import org.elasticsearch.search.SearchHit;
  28 import org.elasticsearch.search.SearchHits;
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.junit.runner.RunWith;
  33 import org.openecomp.sdc.be.config.Configuration;
  34 import org.openecomp.sdc.be.config.Configuration.ElasticSearchConfig.IndicesTimeFrequencyEntry;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.dao.es.ElasticSearchClient;
  37 import org.openecomp.sdc.be.dao.impl.AuditingDao;
  38 import org.openecomp.sdc.be.resources.data.auditing.*;
  39 import org.openecomp.sdc.be.utils.DAOConfDependentTest;
  40 import org.openecomp.sdc.common.api.Constants;
  41 import org.openecomp.sdc.common.datastructure.AuditingFieldsKey;
  42 import org.openecomp.sdc.common.datastructure.ESTimeBasedEvent;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.test.context.ContextConfiguration;
  46 import org.springframework.test.context.TestExecutionListeners;
  47 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  48 import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
  49 import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
  50 import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
  51
  52 import javax.annotation.Resource;
  53 import java.util.ArrayList;
  54 import java.util.HashMap;
  55 import java.util.List;
  56 import java.util.Map;
  57 import java.util.Map.Entry;
  58
  59 import static org.junit.Assert.*;
  60
  61 @RunWith(SpringJUnit4ClassRunner.class)
  62 @ContextConfiguration("classpath:application-context-test.xml")
  63 @TestExecutionListeners(listeners = { DependencyInjectionTestExecutionListener.class,
  64                 DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class })
  65 public class AuditingDaoTest extends DAOConfDependentTest{
  66         private static Logger log = LoggerFactory.getLogger(AuditingDaoTest.class.getName());
  67         @Resource(name = "elasticsearch-client")
  68         private ElasticSearchClient esclient;
  69
  70         @Resource(name = "auditingDao")
  71         private AuditingDao auditingDao;
  72
  73         @After
  74         public void tearDown() {
  75                 deleteOldIndexes();
  76         }
  77
  78         @Before
  79         public void setup() {
  80                 auditingDao.setConfigurationManager(configurationManager);
  81                 deleteOldIndexes();
  82         }
  83
  84         private void deleteOldIndexes() {
  85                 DeleteIndexResponse deleteResponse = esclient.getClient().admin().indices()
  86                                 .prepareDelete(auditingDao.getIndexPrefix() + "*").execute().actionGet();
  87                 if (!deleteResponse.isAcknowledged()) {
  88                         log.debug("Couldn't delete old auditing indexes!");
  89             fail();
  90                 }
  91         }
  92
  93         // @Test
  94         public void testAddUpdateAdminEventMinute() {
  95
  96                 String timestamp = "2015-06-23 13:34:53.123";
  97
  98                 String creationPeriod = Constants.MINUTE;
  99                 String expectedIndexName = auditingDao.getIndexPrefix() + "-2015-06-23-13-34";
 100                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 101                                 .isExists());
 102                 Map<AuditingFieldsKey, Object> params = getUserAdminEventParams(timestamp);
 103                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class);
 104                 params = getUserAccessEventParams(timestamp);
 105                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class);
 106                 params = getResourceAdminEventParams(timestamp, "addResource");
 107                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class);
 108         }
 109
 110         // @Test
 111         public void testAddUpdateAdminEventYearly() {
 112
 113                 String timestamp = "2016-06-23 13:34:53.123";
 114                 String creationPeriod = Constants.YEAR;
 115                 String expectedIndexName = auditingDao.getIndexPrefix() + "-2016";
 116                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 117                                 .isExists());
 118                 Map<AuditingFieldsKey, Object> params = getUserAdminEventParams(timestamp);
 119                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class);
 120                 params = getUserAccessEventParams(timestamp);
 121                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class);
 122                 params = getResourceAdminEventParams(timestamp, "addResource");
 123                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class);
 124         }
 125
 126         @Test
 127         public void testGetDistributionStatusEvent() {
 128
 129                 String timestamp1 = "2016-06-23 13:34:53.123";
 130                 String creationPeriod = Constants.MONTH;
 131                 String expectedIndexName1 = auditingDao.getIndexPrefix() + "-2016-06";
 132                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName1).execute().actionGet()
 133                                 .isExists());
 134                 Map<AuditingFieldsKey, Object> params = getDistributionStatusEventParams(timestamp1);
 135                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName1, DistributionStatusEvent.class);
 136                 String timestamp2 = "2015-06-23 13:34:53.123";
 137
 138                 String expectedIndexName2 = auditingDao.getIndexPrefix() + "-2015-06";
 139                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName2).execute().actionGet()
 140                                 .isExists());
 141                 Map<AuditingFieldsKey, Object> params2 = getDistributionStatusEventParams(timestamp2);
 142                 testCreationPeriodScenario(params2, creationPeriod, expectedIndexName2, DistributionStatusEvent.class);
 143                 Either<List<ESTimeBasedEvent>, ActionStatus> status = auditingDao.getListOfDistributionStatuses("123-456");
 144                 assertEquals(2, status.left().value().size());
 145         }
 146
 147         @Test
 148         public void testGetCountAdminEventMonthly() {
 149
 150                 String timestamp1 = "2016-06-23 13:34:53.123";
 151                 String timestamp2 = "2015-06-23 13:34:53.123";
 152                 String creationPeriod = Constants.MONTH;
 153                 String expectedIndexName1 = auditingDao.getIndexPrefix() + "-2016-06";
 154                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName1).execute().actionGet()
 155                                 .isExists());
 156                 String expectedIndexName2 = auditingDao.getIndexPrefix() + "-2015-06";
 157                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName2).execute().actionGet()
 158                                 .isExists());
 159
 160                 Map<AuditingFieldsKey, Object> params1 = getUserAdminEventParams(timestamp1);
 161                 testCreationPeriodScenario(params1, creationPeriod, expectedIndexName1, UserAdminEvent.class);
 162                 Map<AuditingFieldsKey, Object> params2 = getUserAdminEventParams(timestamp2);
 163                 testCreationPeriodScenario(params2, creationPeriod, expectedIndexName2, UserAdminEvent.class);
 164
 165                 long count = auditingDao.count(UserAdminEvent.class, new MatchAllQueryBuilder());
 166                 log.debug("Testing auditing count {}", count);
 167                 assertEquals(2, count);
 168         }
 169
 170         @Test
 171         public void testServiceDistributionStatuses() {
 172
 173                 String timestamp = "2016-06-23 13:34:53.123";
 174                 String creationPeriod = Constants.MONTH;
 175                 String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06";
 176                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 177                                 .isExists());
 178                 Map<AuditingFieldsKey, Object> params = getUserAdminEventParams(timestamp);
 179                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class);
 180                 params = getUserAccessEventParams(timestamp);
 181                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class);
 182                 params = getResourceAdminEventParams(timestamp, "DRequest");
 183                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class);
 184                 params = getDistributionNotificationEventParams(timestamp);
 185                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, DistributionNotificationEvent.class);
 186                 Either<List<ESTimeBasedEvent>, ActionStatus> status = auditingDao
 187                                 .getServiceDistributionStatusesList("SeviceId");
 188                 log.debug("Testing auditing count {}", status);
 189         }
 190
 191         @Test
 192         public void testAddUpdateAdminEventMonthly() {
 193
 194                 String timestamp = "2016-06-23 13:34:53.123";
 195                 String creationPeriod = Constants.MONTH;
 196                 String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06";
 197                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 198                                 .isExists());
 199                 Map<AuditingFieldsKey, Object> params = getUserAdminEventParams(timestamp);
 200                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAdminEvent.class);
 201                 params = getUserAccessEventParams(timestamp);
 202                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, UserAccessEvent.class);
 203                 params = getResourceAdminEventParams(timestamp, "addResource");
 204                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class);
 205         }
 206
 207         @Test
 208         public void testGetFilteredResourceAdminAuditingEvents() {
 209                 Map<AuditingFieldsKey, Object> filterMap = new HashMap<>();
 210                 filterMap.put(AuditingFieldsKey.AUDIT_ACTION, new Object());
 211                 Either<List<ESTimeBasedEvent>, ActionStatus> filteredResourceAdminAuditingEvents = auditingDao
 212                                 .getFilteredResourceAdminAuditingEvents(filterMap);
 213         }
 214
 215         @Test
 216         public void testGetListOfDistributionByAction() {
 217                 Either<List<ESTimeBasedEvent>, ActionStatus> filteredResourceAdminAuditingEvents = auditingDao
 218                                 .getListOfDistributionByAction("mock", "mock", "mock", AuditingGenericEvent.class);
 219                 filteredResourceAdminAuditingEvents = auditingDao
 220                                 .getListOfDistributionByAction("mock", "mock", null, AuditingGenericEvent.class);
 221         }
 222
 223         private SearchResponse testCreationPeriodScenario(Map<AuditingFieldsKey, Object> params, String creationPeriod,
 224                                                       String expectedIndexName, Class<? extends AuditingGenericEvent> clazz) {
 225
 226                 String typeName = clazz.getSimpleName().toLowerCase();
 227                 log.debug("Testing auditing type {}", typeName);
 228                 setCreationPeriod(creationPeriod);
 229                 ActionStatus saveUserAdminEvent = auditingDao.addRecord(params, typeName);
 230                 assertEquals(ActionStatus.OK, saveUserAdminEvent);
 231                 assertTrue(esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 232                                 .isExists());
 233                 MatchAllQueryBuilder matchAllQueryBuilder = new MatchAllQueryBuilder();
 234
 235                 SearchResponse searchResponse = esclient.getClient().prepareSearch(expectedIndexName).setTypes(typeName)
 236                                 .setQuery(matchAllQueryBuilder).execute().actionGet();
 237
 238                 SearchHits hits = searchResponse.getHits();
 239                 assertEquals(1, hits.getTotalHits());
 240                 log.debug("Checking that all expected fields are properly persisted");
 241                 validateHitValues(params, hits.getAt(0));
 242                 log.debug("testCreationPeriodScenario successful");
 243                 return searchResponse;
 244         }
 245
 246         private void validateHitValues(Map<AuditingFieldsKey, Object> params, SearchHit searchHit) {
 247                 Map<String, Object> source = searchHit.getSource();
 248                 log.debug("Hit source is {}", searchHit.sourceAsString());
 249                 for (Entry<AuditingFieldsKey, Object> paramsEntry : params.entrySet()) {
 250                         AuditingFieldsKey key = paramsEntry.getKey();
 251                         log.debug("Testing auditing field {}", key.name());
 252                         Object value = paramsEntry.getValue();
 253                         // assertEquals(value, source.get(auditField2esField.get(key)));
 254                         assertEquals(value, source.get(key.getDisplayName()));
 255                 }
 256         }
 257
 258         private void setCreationPeriod(String creationPeriod) {
 259                 Configuration configuration = configurationManager.getConfiguration();
 260                 List<IndicesTimeFrequencyEntry> indicesTimeFrequencyEntries = new ArrayList<>();
 261                 IndicesTimeFrequencyEntry indicesTimeFrequencyEntry = new IndicesTimeFrequencyEntry();
 262                 indicesTimeFrequencyEntry.setIndexPrefix("auditingevents");
 263                 indicesTimeFrequencyEntry.setCreationPeriod(creationPeriod);
 264                 configuration.getElasticSearch().setIndicesTimeFrequency(indicesTimeFrequencyEntries);
 265         }
 266
 267         private Map<AuditingFieldsKey, Object> getUserAdminEventParams(String timestamp) {
 268
 269                 Map<AuditingFieldsKey, Object> params = new HashMap<>();
 270                 String action = "updateUser";
 271                 String modifierName = "moshe moshe";
 272                 String modifierUid = "mosheUid";
 273                 String userUid = "mosheUid";
 274                 String userBeforeName = "moshe moshe";
 275                 String userBeforeEmail = "moshe@moshe1.com";
 276                 String userBeforeRole = "TESTER";
 277                 String userAfterName = "moshe moshe";
 278                 String userAfterEmail = "moshe@moshe2.com";
 279                 String userAfterRole = "TESTER";
 280                 String userStatus = "200";
 281                 String userDesc = "OK";
 282
 283                 params.put(AuditingFieldsKey.AUDIT_ACTION, action);
 284                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_UID, modifierName + '(' + modifierUid + ')');
 285                 params.put(AuditingFieldsKey.AUDIT_USER_UID, userUid);
 286                 params.put(AuditingFieldsKey.AUDIT_USER_BEFORE,
 287                                 userUid + ", " + userBeforeName + ", " + userBeforeEmail + ", " + userBeforeRole);
 288                 params.put(AuditingFieldsKey.AUDIT_USER_AFTER,
 289                                 userUid + ", " + userAfterName + ", " + userAfterEmail + ", " + userAfterRole);
 290                 params.put(AuditingFieldsKey.AUDIT_STATUS, userStatus);
 291                 params.put(AuditingFieldsKey.AUDIT_DESC, userDesc);
 292                 params.put(AuditingFieldsKey.AUDIT_TIMESTAMP, timestamp);
 293
 294                 return params;
 295         }
 296
 297         private Map<AuditingFieldsKey, Object> getUserAccessEventParams(String timestamp) {
 298
 299                 Map<AuditingFieldsKey, Object> params = new HashMap<>();
 300                 String action = "userAccess";
 301                 String userUid = "mosheUid";
 302                 String userName = "moshe moshe";
 303                 String userStatus = "200";
 304                 String userDesc = "OK";
 305
 306                 params.put(AuditingFieldsKey.AUDIT_ACTION, action);
 307                 params.put(AuditingFieldsKey.AUDIT_USER_UID, userName + '(' + userUid + ')');
 308                 params.put(AuditingFieldsKey.AUDIT_STATUS, userStatus);
 309                 params.put(AuditingFieldsKey.AUDIT_DESC, userDesc);
 310                 params.put(AuditingFieldsKey.AUDIT_TIMESTAMP, timestamp);
 311
 312                 return params;
 313         }
 314
 315         private Map<AuditingFieldsKey, Object> getResourceAdminEventParams(String timestamp, String action) {
 316
 317                 Map<AuditingFieldsKey, Object> params = new HashMap<>();
 318
 319                 String modifierName = "moshe moshe";
 320                 String modifierUid = "mosheUid";
 321                 String resourceName = "Centos";
 322                 String resourceType = "Resource";
 323                 String currState = "READY_FOR_CERTIFICATION";
 324                 String prevState = "CHECKED_OUT";
 325                 String currVersion = "1.1.4";
 326                 String prevVersion = "1.1.3";
 327                 String status = "200";
 328                 String desc = "OK";
 329                 String distributionId = "123-456";
 330                 String serviceId = "SeviceId";
 331
 332                 params.put(AuditingFieldsKey.AUDIT_ACTION, action);
 333                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_NAME, modifierName);
 334                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_UID, modifierUid);
 335                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_NAME, resourceName);
 336                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_TYPE, resourceType);
 337                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_CURR_STATE, currState);
 338                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_PREV_STATE, prevState);
 339                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_CURR_VERSION, currVersion);
 340                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_PREV_VERSION, prevVersion);
 341                 params.put(AuditingFieldsKey.AUDIT_STATUS, status);
 342                 params.put(AuditingFieldsKey.AUDIT_DESC, desc);
 343                 params.put(AuditingFieldsKey.AUDIT_TIMESTAMP, timestamp);
 344                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_ID, distributionId);
 345                 params.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, serviceId);
 346
 347                 return params;
 348         }
 349
 350         private Map<AuditingFieldsKey, Object> getDistributionStatusEventParams(String timestamp) {
 351
 352                 Map<AuditingFieldsKey, Object> params = new HashMap<>();
 353                 String action = "DStatus";
 354                 String modifierName = "moshe moshe";
 355                 String modifierUid = "mosheUid";
 356                 String topicName = "Centos";
 357                 String serviceId = "SeviceId";
 358                 String resourceUrl = "resourceUrl";
 359                 String distributionId = "123-456";
 360
 361                 String status = "200";
 362                 String desc = "OK";
 363
 364                 params.put(AuditingFieldsKey.AUDIT_DESC, desc);
 365                 params.put(AuditingFieldsKey.AUDIT_TIMESTAMP, timestamp);
 366                 params.put(AuditingFieldsKey.AUDIT_STATUS, status);
 367                 params.put(AuditingFieldsKey.AUDIT_ACTION, action);
 368                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_ID, distributionId);
 369                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_CONSUMER_ID, modifierUid);
 370                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 371                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_RESOURCE_URL, resourceUrl);
 372                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_STATUS_TIME, timestamp);
 373                 params.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, serviceId);
 374
 375                 return params;
 376         }
 377
 378         // @Test
 379         public void getListOfDistributionByActionTest() {
 380
 381                 String timestamp = "2016-06-23 13:34:53.123";
 382                 String distributionId = "123-456";
 383
 384                 String creationPeriod = Constants.MONTH;
 385                 String expectedIndexName = auditingDao.getIndexPrefix() + "-2016-06";
 386                 assertTrue(!esclient.getClient().admin().indices().prepareExists(expectedIndexName).execute().actionGet()
 387                                 .isExists());
 388
 389                 Map<AuditingFieldsKey, Object> params = getResourceAdminEventParams(timestamp, "DRequest");
 390                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_ID, distributionId);
 391                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, ResourceAdminEvent.class);
 392                 params = getDistributionNotificationEventParams(timestamp);
 393                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_ID, distributionId);
 394
 395                 testCreationPeriodScenario(params, creationPeriod, expectedIndexName, DistributionNotificationEvent.class);
 396
 397                 Either<List<ESTimeBasedEvent>, ActionStatus> distributionByAction = auditingDao
 398                                 .getListOfDistributionByAction(distributionId, "DRequest", "200", ResourceAdminEvent.class);
 399                 assertTrue(distributionByAction.isLeft());
 400                 assertFalse(distributionByAction.left().value().isEmpty());
 401
 402                 distributionByAction = auditingDao.getListOfDistributionByAction(distributionId, "DNotify", "200",
 403                                 DistributionNotificationEvent.class);
 404                 assertTrue(distributionByAction.isLeft());
 405                 assertFalse(distributionByAction.left().value().isEmpty());
 406
 407         }
 408
 409         private Map<AuditingFieldsKey, Object> getDistributionNotificationEventParams(String timestamp) {
 410
 411                 Map<AuditingFieldsKey, Object> params = new HashMap<>();
 412
 413                 String action = "DNotify";
 414                 String modifierName = "moshe moshe";
 415                 String modifierUid = "mosheUid";
 416                 String resourceName = "Centos";
 417                 String resourceType = "Resource";
 418
 419                 String currVersion = "1.1.4";
 420                 String currState = "READY_FOR_CERTIFICATION";
 421                 String status = "200";
 422                 String desc = "OK";
 423                 String did = "1027";
 424                 String topicName = "Centos";
 425                 String serviceId = "SeviceId";
 426                 String requestId = "12364";
 427
 428                 params.put(AuditingFieldsKey.AUDIT_ACTION, action);
 429                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_NAME, requestId);
 430                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_UID, modifierUid);
 431                 params.put(AuditingFieldsKey.AUDIT_MODIFIER_NAME, modifierName);
 432                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_NAME, resourceName);
 433                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_TYPE, resourceType);
 434                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_CURR_STATE, currState);
 435                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_TOPIC_NAME, topicName);
 436                 params.put(AuditingFieldsKey.AUDIT_RESOURCE_CURR_VERSION, currVersion);
 437                 params.put(AuditingFieldsKey.AUDIT_STATUS, status);
 438                 params.put(AuditingFieldsKey.AUDIT_DESC, desc);
 439                 params.put(AuditingFieldsKey.AUDIT_TIMESTAMP, timestamp);
 440                 params.put(AuditingFieldsKey.AUDIT_DISTRIBUTION_ID, did);
 441                 params.put(AuditingFieldsKey.AUDIT_SERVICE_INSTANCE_ID, serviceId);
 442                 return params;
 443         }
 444
 445 }