| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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. |
| */ |
| |
| import Ember from 'ember'; |
| import CommonUtils from "../utils/common-utils"; |
| import {SlaInfo} from '../domain/sla-info'; |
| var MappingMixin= Ember.Mixin.create({ |
| handleMapping(nodeDomain,nodeObj,mappings,nodeName){ |
| var self=this; |
| mappings.forEach(function(mapping){ |
| if (mapping.mandatory){ |
| if (!(nodeDomain[mapping.domain] || mapping.customHandler)){ |
| var msgForVal=mapping.domain; |
| if (mapping.displayName){ |
| msgForVal=mapping.displayName; |
| } |
| self.getContext().addError({node:{name:nodeName}, message:"Mandatory element missing for "+msgForVal}); |
| } |
| } |
| if (nodeDomain && mapping.domain && nodeDomain[mapping.domain]){ |
| if (!mapping.occurs){ |
| mapping.occurs="once"; |
| } |
| var objs=[]; |
| if (mapping.occurs==="once"){ |
| objs.push(mapping.ignoreValue?"":nodeDomain[mapping.domain]); |
| }else{ |
| if (mapping.domainProperty){ |
| var tempObjs=[]; |
| nodeDomain[mapping.domain].forEach(function(value){ |
| tempObjs.push(value[mapping.domainProperty]); |
| }); |
| objs=tempObjs; |
| }else{ |
| objs=mapping.ignoreValue?"":nodeDomain[mapping.domain]; |
| } |
| } |
| if (!Ember.isArray(objs) || Ember.isArray(objs)&& objs.length>0){ |
| nodeObj[mapping.xml]=objs; |
| } |
| }else if (mapping.customHandler){ |
| var result=mapping.customHandler.hanldeGeneration(nodeDomain,nodeObj); |
| if (result){ |
| nodeObj[mapping.xml]=result; |
| } |
| } |
| }); |
| }, |
| |
| handleImportMapping(actionNode,json,mappings){ |
| var domain={ |
| unsupportedProperties : {} |
| }; |
| if (json._xmlns){ |
| var version=CommonUtils.extractSchemaVersion(json._xmlns); |
| //this.schemaVersions.setActionVersion(actionNode.actionType,version); |
| } |
| actionNode.set("domain",domain); |
| Object.keys(json).forEach((propKey)=>{ |
| if(!mappings.findBy('xml', propKey) && propKey !=='_xmlns' && propKey !=='@id' && propKey !== '__jsogObjectId'){ |
| domain.unsupportedProperties[propKey] = json[propKey]; |
| domain[propKey] = json[propKey]; |
| } |
| }); |
| mappings.forEach(function(mapping){ |
| if (!mapping.occurs) { |
| mapping.occurs = "once"; |
| } |
| if (mapping.domain && (json[mapping.xml] || json[mapping.xml]==="")){ |
| if (mapping.occurs==="once"){ |
| if (mapping.ignoreValue){ |
| domain[mapping.domain]=json[mapping.xml]!==null || json[mapping.xml]!==undefined; |
| }else{ |
| domain[mapping.domain]=json[mapping.xml]; |
| } |
| }else{ |
| if (!domain[mapping.domain]){ |
| domain[mapping.domain]=Ember.A([]); |
| } |
| if (Ember.isArray(json[mapping.xml])){ |
| if (mapping.domainProperty){ |
| json[mapping.xml].forEach(function(mappingVal){ |
| var obj={}; |
| obj[mapping.domainProperty]= mappingVal; |
| domain[mapping.domain].pushObject(obj); |
| }); |
| }else{ |
| domain[mapping.domain].pushObjects(json[mapping.xml]); |
| } |
| }else{ |
| if(mapping.domainProperty){ |
| var obj = {}; |
| obj[mapping.domainProperty]= json[mapping.xml]; |
| domain[mapping.domain].pushObject(obj); |
| }else{ |
| domain[mapping.domain].pushObject(json[mapping.xml]); |
| } |
| } |
| } |
| }else if (mapping.customHandler){ |
| if (json[mapping.xml]){ |
| mapping.customHandler.handleImport(domain,json[mapping.xml]); |
| } |
| } |
| }); |
| } |
| }); |
| var ConfigurationMapper= Ember.Object.extend({ |
| /* jshint unused:vars */ |
| hanldeGeneration(node,nodeObj){ |
| if (!node || !node.configuration || !node.configuration.property){ |
| return; |
| } |
| var props=[]; |
| node.configuration.property.forEach(function(config){ |
| props.push({name:config.name,value:config.value}); |
| }); |
| if (props.length>0){ |
| var configuration={"property":props}; |
| return configuration; |
| } |
| }, |
| handleImport(domain,nodeObj){ |
| if (!nodeObj.property){ |
| return; |
| } |
| var configs=Ember.A([]); |
| domain.configuration={property:configs}; |
| if (Ember.isArray(nodeObj.property)){ |
| nodeObj.property.forEach(function(prop){ |
| var propObj=Ember.Object.create({ |
| name: prop.name, |
| value: prop.value |
| }); |
| configs.pushObject(propObj); |
| }); |
| }else{ |
| var propObj=Ember.Object.create({ |
| name: nodeObj.property.name, |
| value: nodeObj.property.value |
| }); |
| configs.pushObject(propObj); |
| } |
| } |
| }); |
| |
| var PrepareMapper= Ember.Object.extend({ |
| hanldeGeneration(node,nodeObj){ |
| if (!node){ |
| return; |
| } |
| if (node.prepare && node.prepare.length>0){ |
| node.prepare.sort(function(a,b){ |
| if (a.type==="delete"){ |
| return -1; |
| }else{ |
| return 1; |
| } |
| }); |
| var prepareObjs={}; |
| nodeObj["prepare"]=prepareObjs; |
| node.prepare.forEach(function(prep){ |
| if (!prepareObjs[prep.type]){ |
| prepareObjs[prep.type]=[]; |
| } |
| prepareObjs[prep.type].push({"_path":prep.path}); |
| }); |
| } |
| }, |
| handleImport(domain,nodeObj){ |
| domain.prepare=[]; |
| if (nodeObj.delete){ |
| this.handlePrepActionInternal(domain.prepare,nodeObj.delete,"delete"); |
| } |
| if (nodeObj.mkdir){ |
| this.handlePrepActionInternal(domain.prepare,nodeObj.mkdir,"mkdir"); |
| } |
| |
| }, |
| handlePrepActionInternal(prepareDomain,actionObjs,type){ |
| if (Ember.isArray(actionObjs)){ |
| actionObjs.forEach(function(actionObj){ |
| var obj=Ember.Object.create({ |
| path: actionObj._path, |
| type: type |
| }); |
| prepareDomain.push(obj); |
| }); |
| }else{ |
| var obj=Ember.Object.create({ |
| path: actionObjs._path, |
| type: type |
| }); |
| prepareDomain.push(obj); |
| } |
| } |
| }); |
| var SLAMapper= Ember.Object.extend({ |
| hanldeGeneration(sla,nodeObj){ |
| if (sla){ |
| var slaInfo=nodeObj["info"]={}; |
| var slaPrefix="sla"; |
| slaInfo["__prefix"]=slaPrefix; |
| if (sla.nominalTime){ |
| slaInfo[slaPrefix+":"+"nominal-time"]=sla.nominalTime.value; |
| } |
| if (sla.shouldStart && sla.shouldStart.time){ |
| slaInfo[slaPrefix+":"+"should-start"]="${"+sla.shouldStart.time+ "*"+sla.shouldStart.unit+"}"; |
| } |
| if (sla.shouldEnd && sla.shouldEnd.time){ |
| slaInfo[slaPrefix+":"+"should-end"]="${"+sla.shouldEnd.time+ "*"+sla.shouldEnd.unit+"}"; |
| } |
| if (sla.maxDuration && sla.maxDuration.time){ |
| slaInfo[slaPrefix+":"+"max-duration"]="${"+sla.maxDuration.time+ "*"+sla.maxDuration.unit+"}"; |
| } |
| if (sla.alertEvents){ |
| slaInfo[slaPrefix+":"+"alert-events"]=sla.alertEvents; |
| } |
| if (sla.alertContact){ |
| slaInfo[slaPrefix+":"+"alert-contact"]=sla.alertContact; |
| } |
| if(sla.notificationMessage){ |
| slaInfo[slaPrefix+":"+"notification-msg"]=sla.notificationMessage; |
| } |
| if(sla.upstreamApps){ |
| slaInfo[slaPrefix+":"+"upstream-apps"]=sla.upstreamApps; |
| } |
| } |
| return nodeObj; |
| }, |
| handleImport(domain,infoJson,key){ |
| var sla=domain[key]=SlaInfo.create({}); |
| if (infoJson["nominal-time"] && infoJson["nominal-time"].__text){ |
| sla.nominalTime= this.extractDateField(infoJson["nominal-time"].__text); |
| } |
| if (infoJson["alert-contact"]&& infoJson["alert-contact"].__text){ |
| sla.alertContact=infoJson["alert-contact"].__text; |
| } |
| if (infoJson["alert-events"] && infoJson["alert-events"].__text){ |
| sla.alertEvents=infoJson["alert-events"].__text; |
| } |
| if (infoJson["notification-msg"] && infoJson["notification-msg"].__text){ |
| sla.notificationMessage=infoJson["notification-msg"].__text; |
| } |
| if (infoJson["upstream-apps"] && infoJson["upstream-apps"].__text){ |
| sla.upstreamApps=infoJson["upstream-apps"].__text; |
| } |
| this.processTimePeriods(sla,infoJson,"should-start","shouldStart"); |
| this.processTimePeriods(sla,infoJson,"should-end","shouldEnd"); |
| this.processTimePeriods(sla,infoJson,"max-duration","maxDuration"); |
| }, |
| processTimePeriods(sla,infoJson,key,domainKey){ |
| if (infoJson[key]){ |
| var timeParts=this.parseSlaTime(infoJson[key].__text,key); |
| sla[domainKey].time=timeParts[0]; |
| sla[domainKey].unit=timeParts[1]; |
| } |
| }, |
| parseSlaTime(str,key){ |
| var timePeriod= str.substring(str.indexOf("{")+1,str.indexOf("}")); |
| return timePeriod.split("*"); |
| }, |
| extractDateField(value){ |
| var dateField = {}; |
| var date = new Date(value); |
| dateField.value = value; |
| if(isNaN(date.getTime())){ |
| dateField.displayValue = value; |
| dateField.type = 'expr'; |
| }else{ |
| dateField.type = 'date'; |
| var utcDate = new Date(date.getTime() + date.getTimezoneOffset()*60*1000); |
| dateField.displayValue = moment(utcDate).format("MM/DD/YYYY hh:mm A"); |
| } |
| return dateField; |
| }, |
| }); |
| export {MappingMixin,ConfigurationMapper,PrepareMapper,SLAMapper}; |
