text: // 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) {
      cloudStack.sections.domains = {
          title: 'label.menu.domains',
          id: 'domains',
  
          // Domain tree
          treeView: {
  		overflowScroll: true,
              // Details
              detailView: {
                  name: 'Domain details',
                  viewAll: {
                      label: 'label.accounts',
                      path: 'accounts'
                  },
  
                  // Detail actions
                  actions: {
                      'delete': {
                          label: 'label.action.delete.domain',
                          messages: {
                              notification: function(args) {
                                  return 'label.action.delete.domain';
                              }
                          },
  
                          createForm: {
                              title: 'label.action.delete.domain',
                              desc: 'message.action.delete.domain',
                              createLabel: 'label.delete',
                              preFilter: function(args) {
                                  if (isAdmin()) {
                                      args.$form.find('.form-item[rel=isForced]').css('display', 'inline-block');
                                  }
                              },
                              fields: {
                                  isForced: {
                                      label: 'force.delete',
                                      isBoolean: true,
                                      isHidden: true
                                  }
                              }
                          },
  
                          action: function(args) {
                              var array1 = [];
                              if (args.$form.find('.form-item[rel=isForced]').css("display") != "none") //uncomment after Brian fix it to include $form in args
                                  array1.push("&cleanup=" + (args.data.isForced == "on"));
  
                              $.ajax({
                                  url: createURL("deleteDomain&id=" + args.context.domains[0].id + array1.join("")),
                                  dataType: "json",
                                  async: false,
                                  success: function(json) {
                                      var jid = json.deletedomainresponse.jobid;
                                      args.response.success({
                                          _custom: {
                                              jobId: jid
                                          }
                                      });
  
                                      // Quick fix for proper UI reaction to delete domain
                                      var $item = $('.name.selected').closest('li');
                                      var $itemParent = $item.closest('li');
                                      $itemParent.parent().parent().find('.name:first').click();
                                      $item.remove();
                                  }
                              });
                          },
                          notification: {
                              poll: pollAsyncJobResult
                          }
                      },
  
                      // Edit domain
                      edit: {
                          label: 'label.action.edit.domain',
                          messages: {
                              notification: function(args) {
                                  return 'label.action.edit.domain';
                              }
                          },
                          action: function(args) {
                              var domainObj;
  
                              var data = {
                                  id: args.context.domains[0].id                                
                              };
  
                              if (args.data.name != null) { //args.data.name == undefined means name field is not editable (when log in as normal user or domain admin)
                                  $.extend(data, {
                                      name: args.data.name
                                  });
                              }
                              
                              if (args.data.networkdomain != null) { //args.data.networkdomain == undefined means networkdomain field is not editable (when log in as normal user or domain admin)
                                  $.extend(data, {
                                  	networkdomain: args.data.networkdomain
                                  });
                              }
                             
                              if('name' in data || 'networkdomain' in data)  {                            
  	                            $.ajax({
  	                                url: createURL("updateDomain"),
  	                                async: false,
  	                                data: data,
  	                                success: function(json) {
  	                                    domainObj = json.updatedomainresponse.domain;
  	                                }
  	                            });
                              }
  
                              if (args.data.vmLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=0&max=" + args.data.vmLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["vmLimit"] = args.data.vmLimit;
                                      }
                                  });
                              }
  
                              if (args.data.ipLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=1&max=" + args.data.ipLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["ipLimit"] = args.data.ipLimit;
                                      }
                                  });
                              }
  
                              if (args.data.volumeLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=2&max=" + args.data.volumeLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["volumeLimit"] = args.data.volumeLimit;
                                      }
                                  });
                              }
  
                              if (args.data.snapshotLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=3&max=" + args.data.snapshotLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["snapshotLimit"] = args.data.snapshotLimit;
                                      }
                                  });
                              }
  
                              if (args.data.templateLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=4&max=" + args.data.templateLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["templateLimit"] = args.data.templateLimit;
                                      }
                                  });
                              }
  
                              if (args.data.vpcLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=7&max=" + args.data.vpcLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["vpcLimit"] = args.data.vpcLimit;
                                      }
                                  });
                              }
  
                              if (args.data.cpuLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=8&max=" + args.data.cpuLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["cpuLimit"] = args.data.cpuLimit;
                                      }
                                  });
                              }
  
                              if (args.data.memoryLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=9&max=" + args.data.memoryLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["memoryLimit"] = args.data.memoryLimit;
                                      }
                                  });
                              }
  
                              if (args.data.networkLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=6&max=" + args.data.networkLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["networkLimit"] = args.data.networkLimit;
                                      }
                                  });
                              }
  
                              if (args.data.primaryStorageLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=10&max=" + args.data.primaryStorageLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["primaryStorageLimit"] = args.data.primaryStorageLimit;
                                      }
                                  });
                              }
  
                              if (args.data.secondaryStorageLimit != null) {
                                  $.ajax({
                                      url: createURL("updateResourceLimit&domainid=" + args.context.domains[0].id + "&resourceType=11&max=" + args.data.secondaryStorageLimit),
                                      dataType: "json",
                                      async: false,
                                      success: function(json) {
                                          domainObj["secondaryStorageLimit"] = args.data.secondaryStorageLimit;
                                      }
                                  });
                              }
  
                              args.response.success({
                                  data: domainObj
                              });
                          }
                      },
  
                      // Add domain
                      create: {
                          label: 'label.add.domain',
  
                          action: function(args) {
                              var data = {
                                  parentdomainid: args.context.domains[0].id,
                                  name: args.data.name
                              };
  
                              if (args.data.networkdomain != null && args.data.networkdomain.length > 0) {
                                  $.extend(data, {
                                      networkdomain: args.data.networkdomain
                                  });
                              }
  
                              $.ajax({
                                  url: createURL('createDomain'),
                                  data: data,
                                  success: function(json) {
                                      var item = json.createdomainresponse.domain;
                                      args.response.success({
                                          data: item
                                      });
                                  },
                                  error: function(XMLHttpResponse) {
                                      var errorMsg = parseXMLHttpResponse(XMLHttpResponse);
                                      args.response.error(errorMsg);
                                  }
                              });
                          },
  
                          messages: {
                              notification: function(args) {
                                  return 'label.add.domain';
                              }
                          },
  
                          createForm: {
                              title: 'label.add.domain',
                              desc: 'message.add.domain',
                              fields: {
                                  name: {
                                      label: 'label.name',
                                      docID: 'helpDomainName',
                                      validation: {
                                          required: true
                                      }
                                  },
                                  networkdomain: {
                                      label: 'label.network.domain',
                                      docID: 'helpDomainNetworkDomain',
                                      validation: {
                                          required: false
                                      }
                                  }
                              }
                          }
                      },
  
                      updateResourceCount: {
                          label: 'label.action.update.resource.count',
                          messages: {
                              confirm: function(args) {
                                  return 'message.update.resource.count';
                              },
                              notification: function(args) {
                                  return 'label.action.update.resource.count';
                              }
                          },
                          action: function(args) {
                              $.ajax({
                                  url: createURL("updateResourceCount&domainid=" + args.context.domains[0].id),
                                  dataType: "json",
                                  async: true,
                                  success: function(json) {
                                      //var resourcecounts= json.updateresourcecountresponse.resourcecount;   //do nothing
                                      args.response.success();
                                  }
                              });
                          },
                          notification: {
                              poll: function(args) {
                                  args.complete();
                              }
                          }
                      }
                  },
                  tabs: {
                      details: {
                          title: 'label.details',
                          fields: [{
                              name: {
                                  label: 'label.name',
                                  isEditable: function(args) {
                                      if (isAdmin() && args.domains[0].level != 0) //ROOT domain (whose level is 0) is not allowed to change domain name
                                          return true;
                                      else
                                          return false;
                                  }
                              }
                          }, {
                              id: {
                                  label: 'label.id'
                              },
  
                              path: {
                                  label: 'label.full.path'
                              },
  
                              networkdomain: {
                                  label: 'label.network.domain',
                                  isEditable: function(args) {
                                      if (isAdmin()) 
                                          return true;
                                      else
                                          return false;
                                  }
                              },
                              vmLimit: {
                                  label: 'label.instance.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              ipLimit: {
                                  label: 'label.ip.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              volumeLimit: {
                                  label: 'label.volume.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              snapshotLimit: {
                                  label: 'label.snapshot.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              templateLimit: {
                                  label: 'label.template.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              vpcLimit: {
                                  label: 'label.VPC.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              cpuLimit: {
                                  label: 'label.cpu.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              memoryLimit: {
                                  label: 'label.memory.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              networkLimit: {
                                  label: 'label.network.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              primaryStorageLimit: {
                                  label: 'label.primary.storage.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              secondaryStorageLimit: {
                                  label: 'label.secondary.storage.limits',
                                  isEditable: function(args) {
                                      if (args.domains[0].id == g_domainid) //disallow to update the field on the domain you log in as
                                          return false;
                                      else
                                          return true;
                                  }
                              },
                              accountTotal: {
                                  label: 'label.accounts'
                              },
                              vmTotal: {
                                  label: 'label.instances'
                              },
                              volumeTotal: {
                                  label: 'label.volumes'
                              }
                          }],
                          dataProvider: function(args) {
                              var domainObj = args.context.domains[0];
                              var totalVMs = 0;
                              var totalVolumes = 0;
  
                              $.ajax({
                                  url: createURL("listAccounts&domainid=" + domainObj.id),
                                  async: false,
                                  data: {},
                                  success: function(json) {
                                      var items = json.listaccountsresponse.account;
                                      if (items != null) {
                                          domainObj["accountTotal"] = items.length;
                                          for (var i = 0; i < items.length; i++) {
                                              totalVMs += items[i].vmtotal;
                                              totalVolumes += items[i].volumetotal;
                                          }
                                      } else {
                                          domainObj["accountTotal"] = 0;
                                      }
                                  }
                              });
  
                              $.ajax({
                                  url: createURL("listProjects&domainid=" + domainObj.id),
                                  async: false,
                                  data: {},
                                  success: function(json) {
                                      var items = json.listprojectsresponse.project;
                                      if (items != null) {
                                          for (var i = 0; i < items.length; i++) {
                                              totalVMs += items[i].vmtotal;
                                              totalVolumes += items[i].volumetotal;
                                          }
                                      }
                                  }
                              });
  
                              domainObj["vmTotal"] = totalVMs;
                              domainObj["volumeTotal"] = totalVolumes;
  
                              /* $.ajax({
                  url: createURL("listVirtualMachines&details=min&domainid=" + domainObj.id),
                  async: false,
                  dataType: "json",
                  success: function(json) {
                    var items = json.listvirtualmachinesresponse.virtualmachine;
                    var total;
                    if (items != null)
                      total = items.length;
                    else
                      total = 0;
                    domainObj["vmTotal"] = total;
                  }
                });
  
                $.ajax({
                  url: createURL("listVolumes&domainid=" + domainObj.id),
                  async: false,
                  dataType: "json",
                  success: function(json) {
                    var items = json.listvolumesresponse.volume;
                    var total;
                    if (items != null)
                      total = items.length;
                    else
                      total = 0;
                    domainObj["volumeTotal"] = total;
                  }
                });*/
  
                              $.ajax({
                                  url: createURL("listResourceLimits&domainid=" + domainObj.id),
                                  async: false,
                                  dataType: "json",
                                  success: function(json) {
                                      var limits = json.listresourcelimitsresponse.resourcelimit;
                                      if (limits != null) {
                                          for (var i = 0; i < limits.length; i++) {
                                              var limit = limits[i];
                                              switch (limit.resourcetype) {
                                                  case "0":
                                                      domainObj["vmLimit"] = limit.max;
                                                      break;
                                                  case "1":
                                                      domainObj["ipLimit"] = limit.max;
                                                      break;
                                                  case "2":
                                                      domainObj["volumeLimit"] = limit.max;
                                                      break;
                                                  case "3":
                                                      domainObj["snapshotLimit"] = limit.max;
                                                      break;
                                                  case "4":
                                                      domainObj["templateLimit"] = limit.max;
                                                      break;
                                                  case "6":
                                                      domainObj["networkLimit"] = limit.max;
                                                      break;
                                                  case "7":
                                                      domainObj["vpcLimit"] = limit.max;
                                                      break;
                                                  case "8":
                                                      domainObj["cpuLimit"] = limit.max;
                                                      break;
                                                  case "9":
                                                      domainObj["memoryLimit"] = limit.max;
                                                      break;
                                                  case "10":
                                                      domainObj["primaryStorageLimit"] = limit.max;
                                                      break;
                                                  case "11":
                                                      domainObj["secondaryStorageLimit"] = limit.max;
                                                      break;
                                              }
                                          }
                                      }
                                  }
                              });
  
                              args.response.success({
                                  data: domainObj,
                                  actionFilter: domainActionfilter
                              });
                          }
                      }
                  }
              },
              labelField: 'name',
              dataProvider: function(args) {
                  var parentDomain = args.context.parentDomain;
                  if (parentDomain == null) { //draw root node
                      $.ajax({
                          url: createURL("listDomains&id=" + g_domainid + '&listAll=true'),
                          dataType: "json",
                          async: false,
                          success: function(json) {
                              var domainObjs = json.listdomainsresponse.domain;
                              args.response.success({
                                  actionFilter: domainActionfilter,
                                  data: domainObjs
                              });
                          }
                      });
                  } else {
                      $.ajax({
                          url: createURL("listDomainChildren&id=" + parentDomain.id),
                          dataType: "json",
                          async: false,
                          success: function(json) {
                              var domainObjs = json.listdomainchildrenresponse.domain;
                              args.response.success({
                                  actionFilter: domainActionfilter,
                                  data: domainObjs
                              });
                          }
                      });
                  }
              }
          }
      };
  
      var domainActionfilter = function(args) {
          var jsonObj = args.context.item;
          var allowedActions = [];
          if (isAdmin()) {
              allowedActions.push("create");
              allowedActions.push("edit"); //merge updateResourceLimit into edit
              if (jsonObj.level != 0) { //ROOT domain (whose level is 0) is not allowed to delete
                  allowedActions.push("delete");
              }
          } else if (isDomainAdmin()) { 
          	if (args.context.domains[0].id != g_domainid) { 
          		allowedActions.push("edit"); //merge updateResourceLimit into edit
          	}
          }
          allowedActions.push("updateResourceCount");
          return allowedActions;
      }
  
  })(cloudStack);
  