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

(function(cloudStack, $) {

var requiredNetworkOfferingExists = false;

var networkServiceObjs = [],

serviceCheckboxNames = [];

var serviceFields = [];

cloudStack.sections.configuration = {

title: 'label.menu.service.offerings',

id: 'configuration',

sectionSelect: {

label: 'label.select.offering'

},

sections: {

serviceOfferings: {

type: 'select',

title: 'label.compute.offerings',

listView: {

id: 'serviceOfferings',

label: 'label.menu.service.offerings',

fields: {

name: {

label: 'label.name',

editable: true

},

displaytext: {

label: 'label.description'

}

},

reorder: cloudStack.api.actions.sort('updateServiceOffering', 'serviceOfferings'),

actions: {

add: {

label: 'label.add.compute.offering',

messages: {

confirm: function(args) {

return 'message.add.service.offering';

},

notification: function(args) {

return 'label.add.compute.offering';

}

},

createForm: {

title: 'label.add.compute.offering',

fields: {

name: {

label: 'label.name',

docID: 'helpComputeOfferingName',

validation: {

required: true

}

},

description: {

label: 'label.description',

docID: 'helpComputeOfferingDescription',

validation: {

required: true

}

},

storageType: {

label: 'label.storage.type',

docID: 'helpComputeOfferingStorageType',

select: function(args) {

var items = [];

items.push({

id: 'shared',

description: 'shared'

});

items.push({

id: 'local',

description: 'local'

});

args.response.success({

data: items

});

}

},

provisioningType: {

label: 'label.disk.provisioningtype',

docID: 'helpComputeOfferingProvisioningType',

select: function(args) {

var items = [];

items.push({

id: 'thin',

description: 'thin'

});

items.push({

id: 'sparse',

description: 'sparse'

});

items.push({

id: 'fat',

description: 'fat'

});

args.response.success({

data: items

});

}

},

isCustomized: {

label: 'label.custom',

isBoolean: true,

isReverse: true,

isChecked: false

},

cpuNumber: {

label: 'label.num.cpu.cores',

dependsOn: 'isCustomized',

docID: 'helpComputeOfferingCPUCores',

validation: {

required: true,

number: true

}

},

cpuSpeed: {

label: 'label.cpu.mhz',

dependsOn: 'isCustomized',

docID: 'helpComputeOfferingCPUMHz',

validation: {

required: true,

number: true

}

},

memory: {

label: 'label.memory.mb',

dependsOn: 'isCustomized',

docID: 'helpComputeOfferingMemory',

validation: {

required: true,

number: true

}

},

networkRate: {

label: 'label.network.rate',

docID: 'helpComputeOfferingNetworkRate',

validation: {

required: false, //optional

number: true

}

},

qosType: {

label: 'label.qos.type',

docID: 'helpDiskOfferingQoSType',

select: function(args) {

var items = [];

items.push({

id: '',

description: ''

});

items.push({

id: 'hypervisor',

description: 'hypervisor'

});

items.push({

id: 'storage',

description: 'storage'

});

args.response.success({

data: items

});

args.$select.change(function() {

var $form = $(this).closest('form');

var $isCustomizedIops = $form.find('.form-item[rel=isCustomizedIops]');

var $minIops = $form.find('.form-item[rel=minIops]');

var $maxIops = $form.find('.form-item[rel=maxIops]');

var $hypervisorSnapshotReserve = $form.find('.form-item[rel=hypervisorSnapshotReserve]');

var $diskBytesReadRate = $form.find('.form-item[rel=diskBytesReadRate]');

var $diskBytesWriteRate = $form.find('.form-item[rel=diskBytesWriteRate]');

var $diskIopsReadRate = $form.find('.form-item[rel=diskIopsReadRate]');

var $diskIopsWriteRate = $form.find('.form-item[rel=diskIopsWriteRate]');

var qosId = $(this).val();

if (qosId == 'storage') { // Storage QoS

$diskBytesReadRate.hide();

$diskBytesWriteRate.hide();

$diskIopsReadRate.hide();

$diskIopsWriteRate.hide();

$isCustomizedIops.css('display', 'inline-block');

if ($isCustomizedIops.find('input[type=checkbox]').is(':checked')) {

$minIops.hide();

$maxIops.hide();

} else {

$minIops.css('display', 'inline-block');

$maxIops.css('display', 'inline-block');

}

$hypervisorSnapshotReserve.css('display', 'inline-block');

} else if (qosId == 'hypervisor') { // Hypervisor Qos

$isCustomizedIops.hide();

$minIops.hide();

$maxIops.hide();

$hypervisorSnapshotReserve.hide();

$diskBytesReadRate.css('display', 'inline-block');

$diskBytesWriteRate.css('display', 'inline-block');

$diskIopsReadRate.css('display', 'inline-block');

$diskIopsWriteRate.css('display', 'inline-block');

} else { // No Qos

$diskBytesReadRate.hide();

$diskBytesWriteRate.hide();

$diskIopsReadRate.hide();

$diskIopsWriteRate.hide();

$isCustomizedIops.hide();

$minIops.hide();

$maxIops.hide();

$hypervisorSnapshotReserve.hide();

}

});

}

},

isCustomizedIops: {

label: 'label.custom.disk.iops',

docID: 'helpDiskOfferingCustomDiskIops',

isBoolean: true,

isReverse: true,

isChecked: false

},

minIops: {

label: 'label.disk.iops.min',

docID: 'helpDiskOfferingDiskIopsMin',

dependsOn: 'isCustomizedIops',

validation: {

required: false,

number: true

}

},

maxIops: {

label: 'label.disk.iops.max',

docID: 'helpDiskOfferingDiskIopsMax',

dependsOn: 'isCustomizedIops',

validation: {

required: false,

number: true

}

},

hypervisorSnapshotReserve: {

label: 'label.hypervisor.snapshot.reserve',

docID: 'helpDiskOfferingHypervisorSnapshotReserve',

validation: {

required: false,

number: true

}

},

diskBytesReadRate: {

label: 'label.disk.bytes.read.rate',

docID: 'helpComputeOfferingDiskBytesReadRate',

validation: {

required: false, //optional

number: true

}

},

diskBytesWriteRate: {

label: 'label.disk.bytes.write.rate',

docID: 'helpComputeOfferingDiskBytesWriteRate',

validation: {

required: false, //optional

number: true

}

},

diskIopsReadRate: {

label: 'label.disk.iops.read.rate',

docID: 'helpComputeOfferingDiskIopsReadRate',

validation: {

required: false, //optional

number: true

}

},

diskIopsWriteRate: {

label: 'label.disk.iops.write.rate',

docID: 'helpComputeOfferingDiskIopsWriteRate',

validation: {

required: false, //optional

number: true

}

},

offerHA: {

label: 'label.offer.ha',

docID: 'helpComputeOfferingHA',

isBoolean: true,

isChecked: false

},

storageTags: {

label: 'label.storage.tags',

docID: 'helpComputeOfferingStorageType',

isTokenInput: true,

dataProvider: function(args) {

$.ajax({

url: createURL("listStorageTags"),

dataType: "json",

success: function(json) {

var item = json.liststoragetagsresponse.storagetag;

var tags = [];

if (item != null)

{

tags = $.map(item, function(tag) {

return {

id: tag.name,

name: tag.name

};

});

}

args.response.success({

data: tags,

hintText: _l('hint.type.part.storage.tag'),

noResultsText: _l('hint.no.storage.tags')

});

},

error: function(XMLHttpResponse) {

var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

args.response.error(errorMsg);

}

});

}

},

hostTags: {

label: 'label.host.tags',

docID: 'helpComputeOfferingHostTags',

isTokenInput: true,

dataProvider: function(args) {

$.ajax({

url: createURL("listHostTags"),

dataType: "json",

success: function(json) {

var item = json.listhosttagsresponse.hosttag;

var tags = [];

if (item != null)

{

tags = $.map(item, function(tag) {

return {

id: tag.name,

name: tag.name

};

});

}

args.response.success({

data: tags,

hintText: _l('hint.type.part.host.tag'),

noResultsText: _l('hint.no.host.tags')

});

},

error: function(XMLHttpResponse) {

var errorMsg = parseXMLHttpResponse(XMLHttpResponse);

args.response.error(errorMsg);

}

});

}

},

cpuCap: {

label: 'label.CPU.cap',

isBoolean: true,

isChecked: false,

docID: 'helpComputeOfferingCPUCap'

},

isPublic: {

label: 'label.public',

isBoolean: true,

isReverse: true,

isChecked: true,

docID: 'helpComputeOfferingPublic'

},

isVolatile: {

label: 'label.volatile',

isBoolean: true,

isChecked: false

},

deploymentPlanner: {

label: 'label.deployment.planner',

select: function(args) {

$.ajax({

url: createURL('listDeploymentPlanners'),

dataType: 'json',

success: function(json) {

var items = [{

id: '',

description: ''

}];

var plannerObjs = json.listdeploymentplannersresponse.deploymentPlanner;

$(plannerObjs).each(function() {

items.push({

id: this.name,

description: this.name

});

});

args.response.success({

data: items

});

args.$select.change(function() {

var $form = $(this).closest('form');

var $fields = $form.find('.field');

if ($(this).val() == "ImplicitDedicationPlanner") {

$form.find('[rel=plannerMode]').css('display', 'block');

} else {

$form.find('[rel=plannerMode]').hide();

}

});

}

});

}

},

// plannerKey:{label:'Planner Key' , docID:'helpImplicitPlannerKey'},

plannerMode: {

label: 'label.planner.mode',

select: function(args) {

var items = [];

items.push({

id: '',

description: ''

});

items.push({

id: 'Strict',

description: 'Strict'

});

items.push({

id: 'Preferred',

description: 'Preferred'

});

args.response.success({

data: items

});

}

},

pciDevice: {

label: 'label.gpu',

select: function(args) {

var items = [];

items.push({

id: '',

description: ''

});

items.push({

id: 'Group of NVIDIA Corporation GK107GL [GRID K1] GPUs',

description: 'NVIDIA GRID K1'

});

items.push({

id: 'Group of NVIDIA Corporation GK104GL [GRID K2] GPUs',

description: 'NVIDIA GRID K2'

});

args.response.success({

data: items

});

var vGpuMap = {};

vGpuMap['Group of NVIDIA Corporation GK107GL [GRID K1] GPUs'] = ['passthrough', 'GRID K100', 'GRID K120Q', 'GRID K140Q', 'GRID K160Q', 'GRID K180Q'];

vGpuMap['Group of NVIDIA Corporation GK104GL [GRID K2] GPUs'] = ['passthrough', 'GRID K200', 'GRID K220Q', 'GRID K240Q', 'GRID K260Q', 'GRID K280Q'];

args.$select.change(function() {

var gpu = $(this).val();

if (gpu == '') {

$(this).closest('form').find('.form-item[rel=\"vgpuType\"]').hide();

}

else {

$(this).closest('form').find('.form-item[rel=\"vgpuType\"]').css('display', 'inline-block');

// enable/disable vGPU type options, depending on selected GPU

var $vGpuTypeSelect = $(this).closest('form').find('select[name=vgpuType]');

var $vGpuTypeOptions = $vGpuTypeSelect.find('option');

$vGpuTypeOptions.each(function(index) {

var vGpuTypeOption = $(this).val();

if (vGpuTypeOption == '' || (gpu in vGpuMap && $.inArray(vGpuTypeOption, vGpuMap[gpu]) > -1))

$(this).attr('disabled', false);

else

$(this).attr('disabled', true);

});

//if selected option is disabled, select the first enabled option instead

if ($vGpuTypeSelect.find('option:selected:disabled').length > 0) {

$vGpuTypeSelect.val($vGpuTypeSelect.find('option:enabled:first').val());

}

}

});

}

},

vgpuType: {

label: 'label.vgpu.type',

isHidden: true,

select: function(args) {

var items = [];

items.push({

id: '',

description: ''

});

items.push({

id: 'passthrough',

description: 'passthrough'

});

items.push({

id: 'GRID K100',

description: 'GRID K100'

});

items.push({

id: 'GRID K120Q',

description: 'GRID K120Q'

});

items.push({

id: 'GRID K140Q',

description: 'GRID K140Q'

});

items.push({

id: 'GRID K160Q',

description: 'GRID K160Q'

});

items.push({

id: 'GRID K180Q',

description: 'GRID K180Q'

});

items.push({

id: 'GRID K200',

description: 'GRID K200'

});

items.push({

id: 'GRID K220Q',

description: 'GRID K220Q'

});

items.push({

id: 'GRID K240Q',

description: 'GRID K240Q'

});

items.push({

id: 'GRID K260Q',

description: 'GRID K260Q'

});

items.push({

id: 'GRID K280Q',

description: 'GRID K280Q'

});

args.response.success({

data: items

});

}

},

domainId: {

label: 'label.domain',

docID: 'helpComputeOfferingDomain',

dependsOn: 'isPublic',

select: function(args) {

$.ajax({

url: createURL("listDomains&listAll=true"),

dataType: "json",

async: false,

success: function(json) {

var items = [];

var domainObjs = json.listdomainsresponse.domain;

$(domainObjs).each(function() {

items.push({

id: this.id,

description: this.path

});

});

args.response.success({

data: items

});

}

});

},

isHidden: true

}

}

},

action: function(args) {

var data = {

issystem: false,

name: args.data.name,

displaytext: args.data.description,

storageType: args.data.storageType,

provisioningType :args.data.provisioningType,

customized: (args.data.isCustomized == "on")

};

//custom fields (begin)

if (args.data.isCustomized != "on") {

$.extend(data, {

cpuNumber: args.data.cpuNumber

});

$.extend(data, {

cpuSpeed: args.data.cpuSpeed

});

$.extend(data, {

memory: args.data.memory

});

}

//custom fields (end)

if (args.data.deploymentPlanner != null && args.data.deploymentPlanner.length > 0) {

$.extend(data, {

deploymentplanner: args.data.deploymentPlanner

});

}

var array1 = [];

if (args.data.deploymentPlanner == "ImplicitDedicationPlanner" && args.data.plannerMode != "") {

array1.push("&serviceofferingdetails[0].key" + "=" + "ImplicitDedicationMode");

array1.push("&serviceofferingdetails[0].value" + "=" + args.data.plannerMode);

}

if (args.data.pciDevice != "") {

array1.push("&serviceofferingdetails[1].key" + "=" + "pciDevice");

array1.push("&serviceofferingdetails[1].value" + "=" + args.data.pciDevice);

}

if (args.data.vgpuType != "") {

array1.push("&serviceofferingdetails[2].key" + "=" + "vgpuType");

array1.push("&serviceofferingdetails[2].value" + "=" + args.data.vgpuType);

}

if (args.data.networkRate != null && args.data.networkRate.length > 0) {

$.extend(data, {

networkrate: args.data.networkRate

});

}

if (args.data.qosType == 'storage') {

var customIops = args.data.isCustomizedIops == "on";

$.extend(data, {

customizediops: customIops

});

if (!customIops) {

if (args.data.minIops != null && args.data.minIops.length > 0) {

$.extend(data, {

miniops: args.data.minIops

});

}

if (args.data.maxIops != null && args.data.maxIops.length > 0) {

$.extend(data, {

maxiops: args.data.maxIops

});

}

}

if (args.data.hypervisorSnapshotReserve != null && args.data.hypervisorSnapshotReserve.length > 0) {

$.extend(data, {

hypervisorsnapshotreserve: args.data.hypervisorSnapshotReserve

});

}

} else if (args.data.qosType == 'hypervisor') {

if (args.data.diskBytesReadRate != null && args.data.diskBytesReadRate.length > 0) {

$.extend(data, {

bytesreadrate: args.data.diskBytesReadRate

});

}

if (args.data.diskBytesWriteRate != null && args.data.diskBytesWriteRate.length > 0) {

$.extend(data, {

byteswriterate: args.data.diskBytesWriteRate

});

}

if (args.data.diskIopsReadRate != null && args.data.diskIopsReadRate.length > 0) {

$.extend(data, {

iopsreadrate: args.data.diskIopsReadRate

});

}

if (args.data.diskIopsWriteRate != null && args.data.diskIopsWriteRate.length > 0) {

$.extend(data, {

iopswriterate: args.data.diskIopsWriteRate

});

}

}

$.extend(data, {

offerha: (args.data.offerHA == "on")

});

if (args.data.storageTags != null && args.data.storageTags.length > 0) {

$.extend(data, {

tags: args.data.storageTags

});

}

if (args.data.hostTags != null && args.data.hostTags.length > 0) {

$.extend(data, {

hosttags: args.data.hostTags

});

}

$.extend(data, {

limitcpuuse: (args.data.cpuCap == "on")

});

$.extend(data, {

isvolatile: (args.data.isVolatile == "on")

});

if (args.data.isPublic != "on") {

$.extend(data, {

domainid: args.data.domainId

});

}

$.ajax({

url: createURL('createServiceOffering' + array1.join("")),

data: data,

success: function(json) {

var item = json.createserviceofferingresponse.serviceoffering;

args.response.success({

data: item

});

},

error: function(data) {

args.response.error(parseXMLHttpResponse(data));

}

});

},

notification: {

poll: function(args) {

args.complete();

}

}

}

},

dataProvider: function(args) {

var data = {};

listViewDataProvider(args, data);

$.extend(data, {

issystem: false

});

$.ajax({

url: createURL('listServiceOfferings'),

data: data,

success: function(json) {

var items = json.listserviceofferingsresponse.serviceoffering;

args.response.success({

actionFitler: serviceOfferingActionfilter,

data: items

});

},

error: function(data) {

args.response.error(parseXMLHttpResponse(data));

}

});

},

detailView: {

name: 'Service offering details',

actions: {

edit: {

label: 'label.edit',

action: function(args) {

var data = {

id: args.context.serviceOfferings[0].id,

name: args.data.name,

displaytext: args.data.displaytext

};

$.ajax({

url: createURL('updateServiceOffering'),

data: data,

success: function(json) {

var item = json.updateserviceofferingresponse.serviceoffering;

args.response.success({

data: item

});

},

error: function(data) {

args.response.error(parseXMLHttpResponse(data));

}

});

}

},

remove: {

label: 'label.action.delete.service.offering',

messages: {

confirm: function(args) {

return 'message.action.delete.service.offering';

},

notification: function(args) {

return 'label.action.delete.service.offering';

}

},

action: function(args) {

var data = {

id: args.context.serviceOfferings[0].id

};

$.ajax({

url: createURL('deleteServiceOffering'),

data: data,

async: true,

success: function(json) {

args.response.success();

},

error: function(data) {

args.response.error(parseXMLHttpResponse(data));

}

});

},

notification: {

poll: function(args) {

args.complete();

}

}

}

},

tabs: {

details: {

title: 'label.details',

fields: [{

name: {

label: 'label.name',

isEditable: true,

validation: {

required: true

}

}

}, {

id: {

label: 'label.id'

},

displaytext: {

label: 'label.description',

isEditable: true,

validation: {

required: true

}

},

storagetype: {

label: 'label.storage.type'

},

provisioningtype: {

label: 'label.disk.provisioningtype'

},

cpunumber: {

label: 'label.num.cpu.cores'

},

cpuspeed: {

label: 'label.cpu.mhz',

converter: function(args) {

return cloudStack.converters.convertHz(args);

}

},

memory: {

label: 'label.memory.mb',

converter: function(args) {

if (args == undefined)

return '';

else

return cloudStack.converters.convertBytes(args * 1024 * 1024);

}

},

networkrate: {

label: 'label.network.rate'

},

iscustomizediops: {

label: 'label.custom.disk.iops',

converter: cloudStack.converters.toBooleanText

},

miniops: {

label: 'label.disk.iops.min',

converter: function(args) {

if (args > 0)

return args;

else

return "N/A";

}

},

maxiops: {

label: 'label.disk.iops.max',

converter: function(args) {

if (args > 0)

return args;

else

return "N/A";

}

},

hypervisorsnapshotreserve: {

label: 'label.hypervisor.snapshot.reserve',

converter: function(args) {

if (args > 0)

return args;

else

return "N/A";

}

},

diskBytesReadRate: {

label: 'label.disk.bytes.read.rate'

},

diskBytesWriteRate: {

label: 'label.disk.bytes.write.rate'

},

diskIopsReadRate: {

label: 'label.disk.iops.read.rate'

},

diskIopsWriteRate: {

label: 'label.disk.iops.write.rate'

},

offerha: {

label: 'label.offer.ha',

converter: cloudStack.converters.toBooleanText

},

limitcpuuse: {

label: 'label.CPU.cap',

converter: cloudStack.converters.toBooleanText

},

isvolatile: {

label: 'label.volatile',

converter: cloudStack.converters.toBooleanText

},

deploymentplanner: {

label: 'label.deployment.planner'

},

plannerMode: {

label: 'label.planner.mode'

},

pciDevice: {

label: 'label.gpu'

},

vgpuType: {

label: 'label.vgpu.type'

},

tags: {

label: 'label.storage.tags'

},

hosttags: {

label: 'label.host.tags'

},

domain: {

label: 'label.domain'

},

created: {

label: 'label.created',

converter: cloudStack.converters.toLocalDate

}

}],

dataProvider: function(args) {

var data = {

issystem: false,

id: args.context.serviceOfferings[0].id

};

$.ajax({

url: createURL('listServiceOfferings'),

data: data,

async: true,

success: function(json) {

var item = json.listserviceofferingsresponse.serviceoffering[0];

if (item.deploymentplanner != null && item.serviceofferingdetails != null) {

if (item.deploymentplanner == 'ImplicitDedicationPlanner' && item.serviceofferingdetails.ImplicitDedicationMode != null) {

item.plannerMode = item.serviceofferingdetails.ImplicitDedicationMode;

}

}

if (item.serviceofferingdetails != null) {

item.pciDevice = item.serviceofferingdetails.pciDevice;

item.vgpuType = item.serviceofferingdetails.vgpuType;

}

args.response.success({

actionFitler: serviceOfferingActionfilter,

data: item

});

}

});