vid-app-common/src/main/webapp/app/vid/scripts/services/deleteResumeService.js

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 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 "use strict";
  22
  23 var DeleteResumeService = function($log, AaiService, AsdcService, DataService,
  24         ComponentService, COMPONENT, FIELD, UtilityService,featureFlags) {
  25
  26     var _this = this;
  27
  28     var getAsyncOperationList = function() {
  29         if (DataService.getLoggedInUserId() == null)
  30                         getLoggedInUserID();
  31                 switch (_this.componentId) {
  32                 case COMPONENT.SERVICE:
  33                         return [ getSubscribers, getLcpCloudRegionTenantList ];
  34                 case COMPONENT.NETWORK:
  35                         return [ getLcpCloudRegionTenantList ];
  36                 case COMPONENT.VNF:
  37                         return [ getLcpCloudRegionTenantList ];
  38                 case COMPONENT.VF_MODULE:
  39                         return [ getLcpCloudRegionTenantList ];
  40                 case COMPONENT.VOLUME_GROUP:
  41                         return [ getLcpCloudRegionTenantList ];
  42                 case COMPONENT.CONFIGURATION:
  43                         return [ getLcpCloudRegionTenantList ];
  44                 }
  45         };
  46
  47         var getLcpCloudRegionTenantList = function() {
  48                 AaiService.getLcpCloudRegionTenantList(DataService
  49                                 .getGlobalCustomerId(), DataService.getServiceType(), function(
  50                                 response) {
  51                         DataService.setCloudRegionTenantList(response);
  52                         UtilityService.startNextAsyncOperation();
  53                 });
  54         };
  55
  56         var getLoggedInUserID = function() {
  57                 AaiService.getLoggedInUserID(function(response) {
  58                         DataService.setLoggedInUserId(response.data);
  59                         UtilityService.startNextAsyncOperation();
  60                 });
  61         };
  62
  63         var getSubscribers = function() {
  64                 AaiService.getSubscribers(function(response) {
  65                         DataService.setSubscribers(response);
  66                         UtilityService.startNextAsyncOperation();
  67                 });
  68         };
  69
  70         var internalGetParametersHandler = function() {
  71                 if (angular.isFunction(_this.getParametersHandler)) {
  72                                 if (_this.componentId == COMPONENT.SERVICE) {
  73                                         if ( DataService.getALaCarte() ) {
  74                                                 _this.getParametersHandler({
  75                                                         summaryList : getSummaryList(),
  76                                                         userProvidedList : getUserProvidedList()
  77                                                 }, true);
  78                                         }
  79                                         else {
  80                                                 _this.getParametersHandler({
  81                                                         summaryList : getSummaryList(),
  82                                                         userProvidedList : getUserProvidedList()
  83                                                 }, false);
  84                                         }
  85                         }
  86                         else {
  87                                 _this.getParametersHandler({
  88                                         summaryList : getSummaryList(),
  89                                         userProvidedList : getUserProvidedList()
  90                                 }, false);
  91                         }
  92                 }
  93         };
  94
  95         var getSubscribersParameter = function() {
  96                 var subscribers = DataService.getSubscribers();
  97                 var parameter = FIELD.PARAMETER.SUBSCRIBER_NAME;
  98                 parameter.optionList = [];
  99
 100                 for (var i = 0; i < subscribers.length; i++) {
 101                         parameter.optionList.push({
 102                                 id : subscribers[i][FIELD.ID.GLOBAL_CUSTOMER_ID],
 103                                 name : subscribers[i][FIELD.ID.SUBNAME]
 104                         })
 105                 }
 106                 return parameter;
 107         };
 108
 109         var getServiceId = function() {
 110                 var serviceIdList = DataService.getServiceIdList();
 111                 var parameter = FIELD.PARAMETER.PRODUCT_FAMILY;
 112                 parameter.optionList = new Array();
 113                 for (var i = 0; i < serviceIdList.length; i++) {
 114                         parameter.optionList.push({
 115                                 id : serviceIdList[i].id,
 116                                 name : serviceIdList[i].description
 117                         });
 118                 }
 119                 return parameter;
 120         };
 121
 122         var getUserProvidedList = function() {
 123
 124                 //var parameterList = [ FIELD.PARAMETER.INSTANCE_NAME ];
 125
 126                 var parameterList = [];
 127
 128                 switch (_this.componentId) {
 129                 case COMPONENT.SERVICE:
 130                         if ( DataService.getALaCarte() ) {
 131                                 parameterList = [];
 132                         }
 133                         else {
 134                                 parameterList = parameterList.concat ([getLcpRegion(),
 135                                     FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 136                                     FIELD.PARAMETER.TENANT_DISABLED ]);
 137                         }
 138                         break;
 139                 case COMPONENT.NETWORK:
 140                 case COMPONENT.CONFIGURATION:
 141                 case COMPONENT.VNF:
 142                         parameterList = parameterList.concat([ //getServiceId(),
 143                                         getLcpRegion(), FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 144                                         FIELD.PARAMETER.TENANT_DISABLED ]);
 145                         break;
 146                 case COMPONENT.VF_MODULE:
 147                         parameterList = parameterList.concat([
 148                                 getLcpRegion(),
 149                                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 150                                         FIELD.PARAMETER.TENANT_DISABLED
 151                         ]);
 152
 153                         break;
 154                 case COMPONENT.VOLUME_GROUP:
 155                         parameterList = parameterList.concat([ getLcpRegion(),
 156                                         FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN,
 157                                         FIELD.PARAMETER.TENANT_DISABLED ]);
 158                 }
 159
 160                 //parameterList.push(FIELD.PARAMETER.SUPPRESS_ROLLBACK);
 161
 162                 //addArbitraryParameters(parameterList);
 163
 164                 return parameterList;
 165         };
 166     var getSummaryList = function() {
 167         switch (_this.componentId) {
 168         case COMPONENT.CONFIGURATION:
 169         case COMPONENT.NETWORK:
 170         case COMPONENT.SERVICE:
 171         case COMPONENT.VNF:
 172         case COMPONENT.VF_MODULE:
 173         case COMPONENT.VOLUME_GROUP:
 174             var summaryList = [ {
 175                 name : FIELD.NAME.SUBSCRIBER_NAME,
 176                 value : DataService.getSubscriberName()
 177             }, {
 178                 name : FIELD.NAME.CUSTOMER_ID,
 179                 value : DataService.getGlobalCustomerId()
 180             }, {
 181                 name : FIELD.NAME.SERVICE_UUID,
 182                 value : DataService.getServiceUuid()
 183             }, {
 184                 name : FIELD.NAME.SERVICE_NAME,
 185                 value : DataService.getServiceName()
 186            /* }, {
 187                 name : FIELD.NAME.USER_SERVICE_INSTANCE_NAME,
 188                 value : DataService.getUserServiceInstanceName()*/
 189             } ];
 190
 191                 _this.parameterList = new Array();
 192
 193                 addToList(FIELD.NAME.SERVICE_NAME, DataService.getServiceName());
 194
 195                 switch (_this.componentId) {
 196                 case COMPONENT.SERVICE:
 197                         addToList(FIELD.NAME.SERVICE_INVARIANT_UUID, DataService
 198                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 199                         addToList(FIELD.NAME.SERVICE_VERSION, DataService
 200                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 201                         addToList(FIELD.NAME.SERVICE_UUID, DataService
 202                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 203                         addToList(FIELD.NAME.SERVICE_DESCRIPTION, DataService
 204                                         .getModelInfo(_this.componentId)[FIELD.ID.DESCRIPTION]);
 205                         addToList(FIELD.NAME.SERVICE_CATEGORY, DataService
 206                                         .getModelInfo(_this.componentId)[FIELD.ID.CATEGORY]);
 207                         break;
 208                 case COMPONENT.VF_MODULE:
 209                         addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 210                                         .getSubscriberName());
 211                         addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 212                                         .getServiceInstanceName());
 213                         addToList(FIELD.NAME.MODEL_NAME, DataService
 214                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME]);
 215                         addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 216                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 217                         addToList(FIELD.NAME.MODEL_VERSION, DataService
 218                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 219                         addToList(FIELD.NAME.MODEL_UUID, DataService
 220                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 221                         break;
 222                 case COMPONENT.CONFIGURATION:
 223                 case COMPONENT.NETWORK:
 224                 case COMPONENT.VNF:
 225                 case COMPONENT.VOLUME_GROUP:
 226                         addToList(FIELD.NAME.SUBSCRIBER_NAME, DataService
 227                                         .getSubscriberName());
 228                         addToList(FIELD.NAME.SERVICE_INSTANCE_NAME, DataService
 229                                         .getServiceInstanceName());
 230                         addToList(FIELD.NAME.MODEL_NAME, DataService
 231                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME]);
 232                         addToList(FIELD.NAME.MODEL_INVARIANT_UUID, DataService
 233                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_INVARIANT_ID]);
 234                         addToList(FIELD.NAME.MODEL_VERSION, DataService
 235                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_VERSION]);
 236                         addToList(FIELD.NAME.MODEL_UUID, DataService
 237                                         .getModelInfo(_this.componentId)[FIELD.ID.MODEL_NAME_VERSION_ID]);
 238                         break;
 239                 }
 240
 241             /*var additionalList = ComponentService.getInventoryParameterList(
 242                     _this.componentId, DataService.getInventoryItem());*/
 243                 var additionalList = ComponentService.getDisplayNames(ComponentService
 244                             .getInventoryParameterList(_this.componentId, DataService
 245                                     .getInventoryItem(), true ));
 246
 247             return summaryList.concat(ComponentService
 248                     .getDisplayNames(additionalList));
 249         }
 250     };
 251
 252     var getMsoUrl = function(serviceStatus) {
 253                 switch (_this.componentId) {
 254                         case COMPONENT.CONFIGURATION:
 255                                 return "mso_delete_configuration/"
 256                                         + DataService.getServiceInstanceId() + "/configurations/"
 257                                         + DataService.getConfigurationInstanceId();
 258                         case COMPONENT.NETWORK:
 259                                 return "mso_delete_nw_instance/"
 260                                         + DataService.getServiceInstanceId() + "/networks/"
 261                                         + DataService.getNetworkInstanceId();
 262                         case COMPONENT.SERVICE:
 263                                 if(DataService.getE2EService() === true)
 264                                         return "mso_delete_e2e_svc_instance/"+ DataService.getServiceInstanceId();
 265                                 else
 266                                         return "mso_delete_svc_instance" + "/" + DataService.getServiceInstanceId() + "?serviceStatus="  + serviceStatus;
 267                         case COMPONENT.VNF:
 268                                 return "mso_delete_vnf_instance/"
 269                                         + DataService.getServiceInstanceId() + "/vnfs/"
 270                                         + DataService.getVnfInstanceId();
 271                         case COMPONENT.VF_MODULE:
 272                                 return "mso_delete_vfmodule_instance/"
 273                                         + DataService.getServiceInstanceId() + "/vnfs/"
 274                                         + DataService.getVnfInstanceId() + "/vfModules/"
 275                                         + DataService.getVfModuleInstanceId();
 276                         case COMPONENT.VOLUME_GROUP:
 277                                 return "mso_delete_volumegroup_instance/"
 278                                         + DataService.getServiceInstanceId() + "/vnfs/"
 279                                         + DataService.getVnfInstanceId() + "/volumeGroups/"
 280                                         + DataService.getVolumeGroupInstanceId();
 281                 }
 282     };
 283
 284         var addToList = function(name, value) {
 285                 _this.parameterList.push({
 286                         name : name,
 287                         value : value
 288                 });
 289         };
 290
 291         var buildCloudConfiguration = function(parameterList) {
 292                 var lcpRegion;
 293                 var cloudOwner;
 294
 295                 var lcpRegionOptionId = getValueFromList(FIELD.ID.LCP_REGION, parameterList);
 296
 297                 if (lcpRegionOptionId === FIELD.KEY.LCP_REGION_TEXT) {
 298                         lcpRegion = getValueFromList(FIELD.ID.LCP_REGION_TEXT,
 299                                 parameterList);
 300                         cloudOwner = undefined;
 301                 } else {
 302                         var cloudOwnerAndLcpCloudRegion = getCloudOwnerAndLcpCloudRegionFromOptionId(lcpRegionOptionId);
 303                         lcpRegion = cloudOwnerAndLcpCloudRegion.cloudRegionId;
 304                         cloudOwner = cloudOwnerAndLcpCloudRegion.cloudOwner;
 305                 }
 306
 307                 return {
 308                         lcpCloudRegionId: lcpRegion,
 309                         cloudOwner: featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) ? cloudOwner : undefined,
 310                         tenantId: getValueFromList(FIELD.ID.TENANT, parameterList)
 311                 };
 312         };
 313
 314         var getMsoE2ERequest = function(parameterList) {
 315                 return {
 316                         "globalSubscriberId": DataService.getSubscriberName(),
 317                         "serviceType": DataService.getServiceType()
 318                 };
 319         };
 320
 321     var getMsoRequestDetails = function(parameterList) {
 322         console.log("getMsoRequestDetails invoked");
 323
 324                 //VoLTE logic goes here
 325                 if(DataService.getE2EService() === true) {
 326                         return getMsoE2ERequest(parameterList);
 327                 }
 328
 329                 var inventoryInfo = ComponentService.getInventoryInfo(
 330                         _this.componentId, DataService.getInventoryItem());
 331                 var modelInfo = DataService.getModelInfo(_this.componentId);
 332                 var requestorloggedInId = DataService.getLoggedInUserId();
 333                 if (requestorloggedInId ==  null)
 334                         requestorloggedInId = "";
 335                 var requestDetails = {
 336                                 modelInfo : {
 337                                         modelType : _this.componentId,
 338                                         modelInvariantId : modelInfo.modelInvariantId,
 339                                         modelVersionId : modelInfo.modelNameVersionId,
 340                                         modelName : modelInfo.modelName,
 341                                         modelCustomizationName : modelInfo.modelCustomizationName,
 342                                         modelCustomizationId : modelInfo.customizationUuid,
 343                                         modelVersion : modelInfo.modelVersion
 344                                 },
 345                                 requestInfo : {
 346                                         source : FIELD.ID.VID,
 347                                         requestorId: requestorloggedInId
 348                                 }
 349                 };
 350         if (featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_ADD_MSO_TESTAPI_FIELD)) {
 351             if ((_this.componentId != COMPONENT.SERVICE) || ( DataService.getALaCarte() )) {
 352                 // a-la-carte services AND *any* non-service
 353                 requestDetails.requestParameters = {
 354                     testApi : DataService.getMsoRequestParametersTestApi()
 355                 };
 356             }
 357         }
 358
 359                 console.log("getMsoRequestDetails COMPONENT." + _this.componentId);
 360                 switch (_this.componentId) {
 361                         case COMPONENT.SERVICE:
 362                                 if (!requestDetails.requestParameters) {
 363                     requestDetails.requestParameters = {};
 364                 }
 365                                 requestDetails.requestParameters.aLaCarte = DataService.getALaCarte();
 366                                 if ( !(DataService.getALaCarte()) ) {
 367                                         // for macro delete include cloud config.
 368                                         requestDetails.cloudConfiguration = buildCloudConfiguration(parameterList);
 369                                 }
 370                             break;
 371                         case COMPONENT.VNF:
 372             case COMPONENT.CONFIGURATION:
 373                         case COMPONENT.VF_MODULE:
 374                         case COMPONENT.NETWORK:
 375                         case COMPONENT.VOLUME_GROUP:
 376                                 requestDetails.cloudConfiguration = buildCloudConfiguration(parameterList);
 377                                 break;
 378
 379                         default:
 380                                 requestDetails.cloudConfiguration = {
 381                                         lcpCloudRegionId : DataService.getLcpRegion(),
 382                                         tenantId : DataService.getTenant()
 383                                 };
 384                 }
 385                 return requestDetails;
 386     }
 387
 388     var getLcpRegion = function() {
 389                 var cloudRegionTenantList = DataService.getCloudRegionTenantList();
 390                 var parameter = "";
 391                 if ( UtilityService.hasContents (cloudRegionTenantList) ) {
 392                         parameter = FIELD.PARAMETER.LCP_REGION;
 393                         parameter.optionList = new Array();
 394                         for (var i = 0; i < cloudRegionTenantList.length; i++) {
 395                                 for (var j = 0; j < parameter.optionList.length; j++) {
 396                                         if (parameter.optionList[j].id === cloudRegionTenantList[i].cloudRegionOptionId) {
 397                         parameter.optionList[j].isPermitted =
 398                             parameter.optionList[j].isPermitted || cloudRegionTenantList[i].isPermitted;
 399                         break;
 400                                         }
 401                                 }
 402                                 if (j < parameter.optionList.length) {
 403                                         continue;
 404                                 }
 405
 406                 var optionName = featureFlags.isOn(COMPONENT.FEATURE_FLAGS.FLAG_1810_CR_ADD_CLOUD_OWNER_TO_MSO_REQUEST) && cloudRegionTenantList[i].cloudOwner ?
 407                     cloudRegionTenantList[i].cloudRegionId + " (" + AaiService.removeVendorFromCloudOwner(cloudRegionTenantList[i].cloudOwner).toUpperCase() + ")" :
 408                     cloudRegionTenantList[i].cloudRegionId;
 409
 410                                 parameter.optionList.push({
 411                                         id : cloudRegionTenantList[i].cloudRegionOptionId,
 412                                         name: optionName,
 413                         isPermitted : cloudRegionTenantList[i].isPermitted
 414                         });
 415                         }
 416                 }
 417                 return parameter;
 418         };
 419
 420         var getCloudOwnerAndLcpCloudRegionFromOptionId = function (cloudRegionOptionId) {
 421                 var cloudRegionTenantList = DataService.getCloudRegionTenantList();
 422                 var cloudRegionTenant = _.find(cloudRegionTenantList, {"cloudRegionOptionId": cloudRegionOptionId});
 423                 return {
 424                         cloudOwner: cloudRegionTenant.cloudOwner,
 425                         cloudRegionId: cloudRegionTenant.cloudRegionId
 426                 }
 427         };
 428
 429         var getTenantList = function(cloudRegionOptionId) {
 430                 var parameter = "";
 431                 var cloudRegionTenantList = DataService.getCloudRegionTenantList();
 432                 if ( UtilityService.hasContents (cloudRegionTenantList) ) {
 433                         parameter = FIELD.PARAMETER.TENANT_ENABLED;
 434                         parameter.optionList = new Array();
 435                         for (var i = 0; i < cloudRegionTenantList.length; i++) {
 436                                 if (cloudRegionTenantList[i].cloudRegionOptionId === cloudRegionOptionId) {
 437                                         parameter.optionList.push({
 438                                                 id : cloudRegionTenantList[i].tenantId,
 439                                                 name : cloudRegionTenantList[i].tenantName,
 440                         isPermitted : cloudRegionTenantList[i].isPermitted
 441                     });
 442                                 }
 443                         }
 444                 }
 445                 return parameter;
 446
 447         };
 448
 449         var addOptionList = function(parameter, optionSimpleArray) {
 450                 var optionList = new Array();
 451                 if (!angular.isArray(optionSimpleArray)) {
 452                         return optionList;
 453                 }
 454                 for (var i = 0; i < optionSimpleArray.length; i++) {
 455                         optionList.push({
 456                                 name : optionSimpleArray[i]
 457                         });
 458                 }
 459                 parameter.optionList = optionList;
 460                 return parameter;
 461         };
 462
 463     var getValueFromList = function(id, parameterList) {
 464                 for (var i = 0; i < parameterList.length; i++) {
 465                         if (parameterList[i].id === id) {
 466                                 return parameterList[i].value;
 467                         }
 468                 }
 469         };
 470
 471         var updateUserParameterList = function(updatedId, parameterListControl) {
 472                 if (updatedId === FIELD.ID.LCP_REGION) {
 473                         var list = parameterListControl.getList(updatedId);
 474                         if (list[0].selectedIndex >= 0) {
 475                                 parameterListControl
 476                                                 .updateList([ getTenantList(list[0].value) ]);
 477                         } else {
 478                                 parameterListControl
 479                                                 .updateList([ FIELD.PARAMETER.TENANT_DISABLED ]);
 480                         }
 481                         if (list[0].value === FIELD.KEY.LCP_REGION_TEXT) {
 482                                 parameterListControl
 483                                                 .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_VISIBLE ]);
 484                         } else {
 485                                 parameterListControl
 486                                                 .updateList([ FIELD.PARAMETER.LCP_REGION_TEXT_HIDDEN ]);
 487                         }
 488                 } else if (updatedId === FIELD.ID.SUBSCRIBER_NAME) {
 489                         var list = parameterListControl.getList(updatedId);
 490                         if (list[0].selectedIndex >= 0) {
 491                                 DataService.setGlobalCustomerId(list[0].value);
 492
 493                                 AaiService.getSubscriptionServiceTypeList(DataService
 494                                                 .getGlobalCustomerId(), function(response) {
 495                                         DataService.setSubscriptionServiceTypeList(response);
 496                                         var serviceTypeParameters = FIELD.PARAMETER.SERVICE_TYPE;
 497                                         serviceTypeParameters.optionList = [];
 498
 499                                         for (var i = 0; i < response.length; i++) {
 500                                                 serviceTypeParameters.optionList.push({
 501                                                         "id" : response[i].name,
 502                                                         "name" : response[i].name
 503                                                 });
 504                                         }
 505                                         parameterListControl.updateList([ serviceTypeParameters ]);
 506                                 });
 507
 508                         } else {
 509                                 parameterListControl
 510                                                 .updateList([ FIELD.PARAMETER.SERVICE_TYPE_DISABLED ]);
 511                         }
 512                 }
 513         };
 514
 515     return {
 516                 initializeComponent : function(componentId) {
 517                         _this.componentId = ComponentService.initialize(componentId);
 518                 },
 519                 getComponentDisplayName : ComponentService.getComponentDisplayName,
 520                 getSummaryList : getSummaryList,
 521                 getParameters : function(getParametersHandler) {
 522                         _this.getParametersHandler = getParametersHandler;
 523                         UtilityService.setHttpErrorHandler(_this.httpErrorHandler);
 524                         UtilityService.startAsyncOperations(getAsyncOperationList(),
 525                                         internalGetParametersHandler);
 526                 },
 527                 updateUserParameterList : updateUserParameterList,
 528                 getMsoRequestDetails : getMsoRequestDetails,
 529                 getMsoUrl : getMsoUrl,
 530                 isMacro : DataService.getMacro()
 531     }
 532 }
 533
 534 appDS2.factory("DeleteResumeService", [ "$log", "AaiService", "AsdcService",
 535         "DataService", "ComponentService", "COMPONENT", "FIELD",
 536         "UtilityService","featureFlags", DeleteResumeService ]);