text: /*
   * Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
   *
   * WSO2 Inc. 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.
   */
  
  var validateStep = {};
  var validateInline = {};
  var stepForwardFrom = {};
  var stepBackFrom = {};
  var policy = {};
  var configuredOperations = [];
  
  // Constants to define platform types available
  var platformTypeConstants = {
      "ANDROID": "android",
      "IOS": "ios",
      "WINDOWS": "windows"
  };
  
  // Constants to define platform types ids.
  var platformIds = {
      "ANDROID": 1,
      "IOS": 3,
      "WINDOWS": 2
  };
  
  // Constants to define Android Operation Constants
  var androidOperationConstants = {
      "PASSCODE_POLICY_OPERATION": "passcode-policy",
      "PASSCODE_POLICY_OPERATION_CODE": "PASSCODE_POLICY",
      "CAMERA_OPERATION": "camera",
      "CAMERA_OPERATION_CODE": "CAMERA",
      "ENCRYPT_STORAGE_OPERATION": "encrypt-storage",
      "ENCRYPT_STORAGE_OPERATION_CODE": "ENCRYPT_STORAGE",
      "WIFI_OPERATION": "wifi",
      "WIFI_OPERATION_CODE": "WIFI"
  };
  
  // Constants to define Android Operation Constants
  var windowsOperationConstants = {
      "PASSCODE_POLICY_OPERATION": "passcode-policy",
      "PASSCODE_POLICY_OPERATION_CODE": "PASSCODE_POLICY",
      "CAMERA_OPERATION": "camera",
      "CAMERA_OPERATION_CODE": "CAMERA",
      "ENCRYPT_STORAGE_OPERATION": "encrypt-storage",
      "ENCRYPT_STORAGE_OPERATION_CODE": "ENCRYPT_STORAGE"
  };
  
  // Constants to define iOS Operation Constants
  var iosOperationConstants = {
      "PASSCODE_POLICY_OPERATION": "passcode-policy",
      "PASSCODE_POLICY_OPERATION_CODE": "PASSCODE_POLICY",
      "RESTRICTIONS_OPERATION": "restrictions",
      "RESTRICTIONS_OPERATION_CODE": "RESTRICTION",
      "WIFI_OPERATION": "wifi",
      "WIFI_OPERATION_CODE": "WIFI",
      "EMAIL_OPERATION": "email",
      "EMAIL_OPERATION_CODE": "EMAIL",
      "AIRPLAY_OPERATION": "airplay",
      "AIRPLAY_OPERATION_CODE": "AIR_PLAY",
      "LDAP_OPERATION": "ldap",
      "LDAP_OPERATION_CODE": "LDAP",
      "CALENDAR_OPERATION": "calendar",
      "CALENDAR_OPERATION_CODE": "CALDAV",
      "CALENDAR_SUBSCRIPTION_OPERATION": "calendar-subscription",
      "CALENDAR_SUBSCRIPTION_OPERATION_CODE": "CALENDAR_SUBSCRIPTION",
      "APN_OPERATION": "apn",
      "APN_OPERATION_CODE": "APN",
      "CELLULAR_OPERATION": "cellular",
      "CELLULAR_OPERATION_CODE": "CELLULAR"
  };
  
  /**
   * Method to update the visibility of grouped input.
   * @param domElement HTML grouped-input element with class name "grouped-input"
   */
  var updateGroupedInputVisibility = function (domElement) {
      if ($(".parent-input:first", domElement).is(":checked")) {
          if ($(".grouped-child-input:first", domElement).hasClass("disabled")) {
              $(".grouped-child-input:first", domElement).removeClass("disabled");
          }
          $(".child-input", domElement).each(function () {
              $(this).prop('disabled', false);
          });
      } else {
          if (!$(".grouped-child-input:first", domElement).hasClass("disabled")) {
              $(".grouped-child-input:first", domElement).addClass("disabled");
          }
          $(".child-input", domElement).each(function () {
              $(this).prop('disabled', true);
          });
      }
  };
  
  var validateInline = {};
  var clearInline = {};
  
  var enableInlineError = function (inputField, errorMsg, errorSign) {
      var fieldIdentifier = "#" + inputField;
      var errorMsgIdentifier = "#" + inputField + " ." + errorMsg;
      var errorSignIdentifier = "#" + inputField + " ." + errorSign;
  
      if (inputField) {
          $(fieldIdentifier).addClass(" has-error has-feedback");
      }
  
      if (errorMsg) {
          $(errorMsgIdentifier).removeClass(" hidden");
      }
  
      if (errorSign) {
          $(errorSignIdentifier).removeClass(" hidden");
      }
  };
  
  var disableInlineError = function (inputField, errorMsg, errorSign) {
      var fieldIdentifier = "#" + inputField;
      var errorMsgIdentifier = "#" + inputField + " ." + errorMsg;
      var errorSignIdentifier = "#" + inputField + " ." + errorSign;
  
      if (inputField) {
          $(fieldIdentifier).removeClass(" has-error has-feedback");
      }
  
      if (errorMsg) {
          $(errorMsgIdentifier).addClass(" hidden");
      }
  
      if (errorSign) {
          $(errorSignIdentifier).addClass(" hidden");
      }
  };
  
  /**
   *clear inline validation messages.
   */
  clearInline["policy-name"] = function () {
      disableInlineError("plicynameField", "nameEmpty", "nameError");
  };
  
  
  /**
   * Validate if provided policy name is valid against RegEx configures.
   */
  validateInline["policy-name"] = function () {
      var policyName = $("input#policy-name-input").val();
      if (policyName && inputIsValidAgainstLength(policyName, 1, 30)) {
          disableInlineError("plicynameField", "nameEmpty", "nameError");
      } else {
          enableInlineError("plicynameField", "nameEmpty", "nameError");
      }
  };
  
  $("#policy-name-input").focus(function () {
      clearInline["policy-name"]();
  });
  
  $("#policy-name-input").blur(function () {
      validateInline["policy-name"]();
  });
  
  /**
   * Checks if provided number is valid against a range.
   *
   * @param numberInput Number Input
   * @param min Minimum Limit
   * @param max Maximum Limit
   * @returns {boolean} Returns true if input is within the specified range
   */
  var inputIsValidAgainstRange = function (numberInput, min, max) {
      return (numberInput == min || (numberInput > min && numberInput < max) || numberInput == max);
  };
  
  /**
   * Checks if provided input is valid against RegEx input.
   *
   * @param regExp Regular expression
   * @param input Input string to check
   * @returns {boolean} Returns true if input matches RegEx
   */
  var inputIsValidAgainstRegExp = function (regExp, input) {
      return regExp.test(input);
  };
  
  validateStep["policy-profile"] = function () {
      var validationStatusArray = [];
      var validationStatus;
      var operation;
  
      // starting validation process and updating validationStatus
      if (policy["platform"] == platformTypeConstants["ANDROID"]) {
          if (configuredOperations.length == 0) {
              // updating validationStatus
              validationStatus = {
                  "error": true,
                  "mainErrorMsg": "You cannot continue. Zero configured features."
              };
              // updating validationStatusArray with validationStatus
              validationStatusArray.push(validationStatus);
          } else {
              // validating each and every configured Operation
              // Validating PASSCODE_POLICY
              if ($.inArray(androidOperationConstants["PASSCODE_POLICY_OPERATION_CODE"], configuredOperations) != -1) {
                  // if PASSCODE_POLICY is configured
                  operation = androidOperationConstants["PASSCODE_POLICY_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  var continueToCheckNextInputs = true;
  
                  // validating first input: passcodePolicyMaxPasscodeAgeInDays
                  var passcodePolicyMaxPasscodeAgeInDays = $("input#passcode-policy-max-passcode-age-in-days").val();
                  if (passcodePolicyMaxPasscodeAgeInDays) {
                      if (!$.isNumeric(passcodePolicyMaxPasscodeAgeInDays)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not a number.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (!inputIsValidAgainstRange(passcodePolicyMaxPasscodeAgeInDays, 1, 730)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not with in the range of 1-to-730.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // validating second and last input: passcodePolicyPasscodeHistory
                  if (continueToCheckNextInputs) {
                      var passcodePolicyPasscodeHistory = $("input#passcode-policy-passcode-history").val();
                      if (passcodePolicyPasscodeHistory) {
                          if (!$.isNumeric(passcodePolicyPasscodeHistory)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not a number.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (!inputIsValidAgainstRange(passcodePolicyPasscodeHistory, 1, 50)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not with in the range of 1-to-50.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating CAMERA
              if ($.inArray(androidOperationConstants["CAMERA_OPERATION_CODE"], configuredOperations) != -1) {
                  // if CAMERA is configured
                  operation = androidOperationConstants["CAMERA_OPERATION"];
                  // updating validationStatus
                  validationStatus = {
                      "error": false,
                      "okFeature": operation
                  };
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating ENCRYPT_STORAGE
              if ($.inArray(androidOperationConstants["ENCRYPT_STORAGE_OPERATION_CODE"], configuredOperations) != -1) {
                  // if ENCRYPT_STORAGE is configured
                  operation = androidOperationConstants["ENCRYPT_STORAGE_OPERATION"];
                  // updating validationStatus
                  validationStatus = {
                      "error": false,
                      "okFeature": operation
                  };
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating WIFI
              if ($.inArray(androidOperationConstants["WIFI_OPERATION_CODE"], configuredOperations) != -1) {
                  // if WIFI is configured
                  operation = androidOperationConstants["WIFI_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var wifiSSID = $("input#wifi-ssid").val();
                  if (!wifiSSID) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "WIFI SSID is not given. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
          }
      }
      if (policy["platform"] == platformTypeConstants["WINDOWS"]) {
          if (configuredOperations.length == 0) {
              // updating validationStatus
              validationStatus = {
                  "error": true,
                  "mainErrorMsg": "You cannot continue. Zero configured features."
              };
              // updating validationStatusArray with validationStatus
              validationStatusArray.push(validationStatus);
          } else {
              // validating each and every configured Operation
              // Validating PASSCODE_POLICY
              if ($.inArray(windowsOperationConstants["PASSCODE_POLICY_OPERATION_CODE"], configuredOperations) != -1) {
                  // if PASSCODE_POLICY is configured
                  operation = windowsOperationConstants["PASSCODE_POLICY_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  var continueToCheckNextInputs = true;
  
                  // validating first input: passcodePolicyMaxPasscodeAgeInDays
                  var passcodePolicyMaxPasscodeAgeInDays = $("input#passcode-policy-max-passcode-age-in-days").val();
                  if (passcodePolicyMaxPasscodeAgeInDays) {
                      if (!$.isNumeric(passcodePolicyMaxPasscodeAgeInDays)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not a number.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (!inputIsValidAgainstRange(passcodePolicyMaxPasscodeAgeInDays, 1, 730)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not with in the range of 1-to-730.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // validating second and last input: passcodePolicyPasscodeHistory
                  if (continueToCheckNextInputs) {
                      var passcodePolicyPasscodeHistory = $("input#passcode-policy-passcode-history").val();
                      if (passcodePolicyPasscodeHistory) {
                          if (!$.isNumeric(passcodePolicyPasscodeHistory)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not a number.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (!inputIsValidAgainstRange(passcodePolicyPasscodeHistory, 1, 50)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not with in the range of 1-to-50.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating CAMERA
              if ($.inArray(windowsOperationConstants["CAMERA_OPERATION_CODE"], configuredOperations) != -1) {
                  // if CAMERA is configured
                  operation = windowsOperationConstants["CAMERA_OPERATION"];
                  // updating validationStatus
                  validationStatus = {
                      "error": false,
                      "okFeature": operation
                  };
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating ENCRYPT_STORAGE
              if ($.inArray(windowsOperationConstants["ENCRYPT_STORAGE_OPERATION_CODE"], configuredOperations) != -1) {
                  // if ENCRYPT_STORAGE is configured
                  operation = windowsOperationConstants["ENCRYPT_STORAGE_OPERATION"];
                  // updating validationStatus
                  validationStatus = {
                      "error": false,
                      "okFeature": operation
                  };
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
  
          }
      } else if (policy["platform"] == platformTypeConstants["IOS"]) {
          if (configuredOperations.length == 0) {
              // updating validationStatus
              validationStatus = {
                  "error": true,
                  "mainErrorMsg": "You cannot continue. Zero configured features."
              };
              // updating validationStatusArray with validationStatus
              validationStatusArray.push(validationStatus);
          } else {
              // validating each and every configured Operation
              // Validating PASSCODE_POLICY
              if ($.inArray(iosOperationConstants["PASSCODE_POLICY_OPERATION_CODE"], configuredOperations) != -1) {
                  // if PASSCODE_POLICY is configured
                  operation = iosOperationConstants["PASSCODE_POLICY_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  // validating first input: passcodePolicyMaxPasscodeAgeInDays
                  passcodePolicyMaxPasscodeAgeInDays = $("input#passcode-policy-max-passcode-age-in-days").val();
                  if (passcodePolicyMaxPasscodeAgeInDays) {
                      if (!$.isNumeric(passcodePolicyMaxPasscodeAgeInDays)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not a number.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (!inputIsValidAgainstRange(passcodePolicyMaxPasscodeAgeInDays, 1, 730)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Provided passcode age is not with in the range of 1-to-730.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // validating second and last input: passcodePolicyPasscodeHistory
                  if (continueToCheckNextInputs) {
                      passcodePolicyPasscodeHistory = $("input#passcode-policy-passcode-history").val();
                      if (passcodePolicyPasscodeHistory) {
                          if (!$.isNumeric(passcodePolicyPasscodeHistory)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not a number.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (!inputIsValidAgainstRange(passcodePolicyPasscodeHistory, 1, 50)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Provided passcode history is not with in the range of 1-to-50.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating RESTRICTIONS
              if ($.inArray(iosOperationConstants["RESTRICTIONS_OPERATION_CODE"], configuredOperations) != -1) {
                  // if RESTRICTION is configured
                  operation = iosOperationConstants["RESTRICTIONS_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  // getting input values to be validated
                  var restrictionsAutonomousSingleAppModePermittedAppIDsGridChildInputs =
                      "div#restrictions-autonomous-single-app-mode-permitted-app-ids .child-input";
                  if ($(restrictionsAutonomousSingleAppModePermittedAppIDsGridChildInputs).length > 0) {
                      var childInput;
                      var childInputArray = [];
                      var emptyChildInputCount = 0;
                      var duplicatesExist = false;
                      // looping through each child input
                      $(restrictionsAutonomousSingleAppModePermittedAppIDsGridChildInputs).each(function () {
                          childInput = $(this).val();
                          childInputArray.push(childInput);
                          if (!childInput) {
                              // if child input field is empty
                              emptyChildInputCount++;
                          }
                      });
                      // checking for duplicates
                      var initialChildInputArrayLength = childInputArray.length;
                      if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                          var m, poppedChildInput;
                          for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                              poppedChildInput = childInputArray.pop();
                              var n;
                              for (n = 0; n < childInputArray.length; n++) {
                                  if (poppedChildInput == childInputArray[n]) {
                                      duplicatesExist = true;
                                      break;
                                  }
                              }
                              if (duplicatesExist) {
                                  break;
                              }
                          }
                      }
                      // updating validationStatus
                      if (emptyChildInputCount > 0) {
                          // if empty child inputs are present
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "One or more permitted App ID entries in " +
                                  "Autonomous Single App Mode are empty.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (duplicatesExist) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Duplicate values exist with permitted App ID entries in " +
                                  "Autonomous Single App Mode.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating WIFI
              if ($.inArray(iosOperationConstants["WIFI_OPERATION_CODE"], configuredOperations) != -1) {
                  // if WIFI is configured
                  operation = iosOperationConstants["WIFI_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  // getting input values to be validated
                  wifiSSID = $("input#wifi-ssid").val();
                  var wifiDomainName = $("input#wifi-domain-name").val();
                  if (!wifiSSID && !wifiDomainName) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "Both Wi-Fi SSID and Wi-Fi Domain Name are not given. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      // getting proxy-setup value
                      var wifiProxyType = $("select#wifi-proxy-type").find("option:selected").attr("value");
                      if (wifiProxyType == "Manual") {
                          // adds up additional fields to be validated
                          var wifiProxyServer = $("input#wifi-proxy-server").val();
                          if (!wifiProxyServer) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Wi-Fi Proxy Server is required. You cannot proceed.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
  
                          if (continueToCheckNextInputs) {
                              var wifiProxyPort = $("input#wifi-proxy-port").val();
                              if (!wifiProxyPort) {
                                  validationStatus = {
                                      "error": true,
                                      "subErrorMsg": "Wi-Fi Proxy Port is required. You cannot proceed.",
                                      "erroneousFeature": operation
                                  };
                                  continueToCheckNextInputs = false;
                              } else if (!$.isNumeric(wifiProxyPort)) {
                                  validationStatus = {
                                      "error": true,
                                      "subErrorMsg": "Wi-Fi Proxy Port requires a number input.",
                                      "erroneousFeature": operation
                                  };
                                  continueToCheckNextInputs = false;
                              } else if (!inputIsValidAgainstRange(wifiProxyPort, 0, 65535)) {
                                  validationStatus = {
                                      "error": true,
                                      "subErrorMsg": "Wi-Fi Proxy Port is not within the range " +
                                          "of valid port numbers.",
                                      "erroneousFeature": operation
                                  };
                                  continueToCheckNextInputs = false;
                              }
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      // getting encryption-type value
                      var wifiEncryptionType = $("select#wifi-encryption-type").find("option:selected").attr("value");
                      if (wifiEncryptionType != "None") {
                          var wifiPayloadCertificateAnchorUUIDsGridChildInputs =
                              "div#wifi-payload-certificate-anchor-uuids .child-input";
                          if ($(wifiPayloadCertificateAnchorUUIDsGridChildInputs).length > 0) {
                              emptyChildInputCount = 0;
                              childInputArray = [];
                              duplicatesExist = false;
                              // looping through each child input
                              $(wifiPayloadCertificateAnchorUUIDsGridChildInputs).each(function () {
                                  childInput = $(this).val();
                                  childInputArray.push(childInput);
                                  if (!childInput) {
                                      // if child input field is empty
                                      emptyChildInputCount++;
                                  }
                              });
                              // checking for duplicates
                              initialChildInputArrayLength = childInputArray.length;
                              if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                                  for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                      poppedChildInput = childInputArray.pop();
                                      for (n = 0; n < childInputArray.length; n++) {
                                          if (poppedChildInput == childInputArray[n]) {
                                              duplicatesExist = true;
                                              break;
                                          }
                                      }
                                      if (duplicatesExist) {
                                          break;
                                      }
                                  }
                              }
                              // updating validationStatus
                              if (emptyChildInputCount > 0) {
                                  // if empty child inputs are present
                                  validationStatus = {
                                      "error": true,
                                      "subErrorMsg": "One or more Payload Certificate " +
                                          "Anchor UUIDs are empty.",
                                      "erroneousFeature": operation
                                  };
                                  continueToCheckNextInputs = false;
                              } else if (duplicatesExist) {
                                  validationStatus = {
                                      "error": true,
                                      "subErrorMsg": "Duplicate values exist " +
                                          "with Payload Certificate Anchor UUIDs.",
                                      "erroneousFeature": operation
                                  };
                                  continueToCheckNextInputs = false;
                              }
                          }
  
                          if (continueToCheckNextInputs) {
                              var wifiTLSTrustedServerNamesGridChildInputs =
                                  "div#wifi-tls-trusted-server-names .child-input";
                              if ($(wifiTLSTrustedServerNamesGridChildInputs).length > 0) {
                                  emptyChildInputCount = 0;
                                  childInputArray = [];
                                  duplicatesExist = false;
                                  // looping through each child input
                                  $(wifiTLSTrustedServerNamesGridChildInputs).each(function () {
                                      childInput = $(this).val();
                                      childInputArray.push(childInput);
                                      if (!childInput) {
                                          // if child input field is empty
                                          emptyChildInputCount++;
                                      }
                                  });
                                  // checking for duplicates
                                  initialChildInputArrayLength = childInputArray.length;
                                  if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                                      for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                          poppedChildInput = childInputArray.pop();
                                          for (n = 0; n < childInputArray.length; n++) {
                                              if (poppedChildInput == childInputArray[n]) {
                                                  duplicatesExist = true;
                                                  break;
                                              }
                                          }
                                          if (duplicatesExist) {
                                              break;
                                          }
                                      }
                                  }
                                  // updating validationStatus
                                  if (emptyChildInputCount > 0) {
                                      // if empty child inputs are present
                                      validationStatus = {
                                          "error": true,
                                          "subErrorMsg": "One or more TLS Trusted Server Names are empty.",
                                          "erroneousFeature": operation
                                      };
                                      continueToCheckNextInputs = false;
                                  } else if (duplicatesExist) {
                                      validationStatus = {
                                          "error": true,
                                          "subErrorMsg": "Duplicate values exist " +
                                              "with TLS Trusted Server Names.",
                                          "erroneousFeature": operation
                                      };
                                      continueToCheckNextInputs = false;
                                  }
                              }
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var wifiRoamingConsortiumOIsGridChildInputs = "div#wifi-roaming-consortium-ois .child-input";
                      if ($(wifiRoamingConsortiumOIsGridChildInputs).length > 0) {
                          emptyChildInputCount = 0;
                          var outOfAllowedLengthCount = 0;
                          var invalidAgainstRegExCount = 0;
                          childInputArray = [];
                          duplicatesExist = false;
                          // looping through each child input
                          $(wifiRoamingConsortiumOIsGridChildInputs).each(function () {
                              childInput = $(this).val();
                              childInputArray.push(childInput);
                              if (!childInput) {
                                  // if child input field is empty
                                  emptyChildInputCount++;
                              } else if (!inputIsValidAgainstLength(childInput, 6, 6) && !inputIsValidAgainstLength(childInput, 10, 10)) {
                                  outOfAllowedLengthCount++;
                              } else if (!inputIsValidAgainstRegExp(/^[a-fA-F0-9]+$/, childInput)) {
                                  invalidAgainstRegExCount++;
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more Roaming Consortium OIs are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (outOfAllowedLengthCount > 0) {
                              // if outOfMaxAllowedLength input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more Roaming Consortium OIs " +
                                      "are out of allowed length.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (invalidAgainstRegExCount > 0) {
                              // if invalid inputs in terms of hexadecimal format are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more Roaming Consortium OIs " +
                                      "contain non-hexadecimal characters.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with Roaming Consortium OIs.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var wifiNAIRealmNamesGridChildInputs = "div#wifi-nai-realm-names .child-input";
                      if ($(wifiNAIRealmNamesGridChildInputs).length > 0) {
                          emptyChildInputCount = 0;
                          childInputArray = [];
                          duplicatesExist = false;
                          // looping through each child input
                          $(wifiNAIRealmNamesGridChildInputs).each(function () {
                              childInput = $(this).val();
                              childInputArray.push(childInput);
                              if (!childInput) {
                                  // if child input field is empty
                                  emptyChildInputCount++;
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more NAI Realm Names are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with NAI Realm Names.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var wifiMCCAndMNCsGridChildInputs = "div#wifi-mcc-and-mncs .child-input";
                      if ($(wifiMCCAndMNCsGridChildInputs).length > 0) {
                          var childInputCount = 0;
                          var stringPair;
                          emptyChildInputCount = 0;
                          outOfAllowedLengthCount = 0;
                          var notNumericInputCount = 0;
                          childInputArray = [];
                          duplicatesExist = false;
                          // looping through each child input
                          $(wifiMCCAndMNCsGridChildInputs).each(function () {
                              childInput = $(this).val();
                              // pushing each string pair to childInputArray
                              childInputCount++;
                              if (childInputCount % 2 == 1) {
                                  // initialize stringPair value
                                  stringPair = "";
                                  // append first part of the string
                                  stringPair += childInput;
                              } else {
                                  // append second part of the string
                                  stringPair += childInput;
                                  childInputArray.push(stringPair);
                              }
                              // updating emptyChildInputCount & outOfAllowedLengthCount
                              if (!childInput) {
                                  // if child input field is empty
                                  emptyChildInputCount++;
                              } else if (!$.isNumeric(childInput)) {
                                  notNumericInputCount++;
                              } else if (!inputIsValidAgainstLength(childInput, 3, 3)) {
                                  outOfAllowedLengthCount++;
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more MCC/MNC pairs are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (notNumericInputCount > 0) {
                              // if notNumeric input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more MCC/MNC pairs are not numeric.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (outOfAllowedLengthCount > 0) {
                              // if outOfAllowedLength input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more MCC/MNC pairs " +
                                      "do not fulfill the accepted length of 6 digits.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with MCC/MNC pairs.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating EMAIL
              if ($.inArray(iosOperationConstants["EMAIL_OPERATION_CODE"], configuredOperations) != -1) {
                  // if EMAIL is configured
                  operation = iosOperationConstants["EMAIL_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var emailAddress = $("input#email-address").val();
                  if (emailAddress && !inputIsValidAgainstRegExp(/^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/, emailAddress)) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "Email Address is not valid.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      var emailIncomingMailServerHostname = $("input#email-incoming-mail-server-hostname").val();
                      if (!emailIncomingMailServerHostname) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Incoming Mail Server Hostname is empty. You cannot proceed.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var emailIncomingMailServerPort = $("input#email-incoming-mail-server-port").val();
                      if (emailIncomingMailServerPort && emailIncomingMailServerPort != '') {
                          if (!$.isNumeric(emailIncomingMailServerPort)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Incoming Mail Server Port requires a number input.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (!inputIsValidAgainstRange(emailIncomingMailServerPort, 0, 65535)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Incoming Mail Server Port is not within the range " +
                                      "of valid port numbers.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var emailOutgoingMailServerHostname = $("input#email-outgoing-mail-server-hostname").val();
                      if (!emailOutgoingMailServerHostname) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Outgoing Mail Server Hostname is empty. You cannot proceed.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      var emailOutgoingMailServerPort = $("input#email-outgoing-mail-server-port").val();
                      if (emailOutgoingMailServerPort) {
                          if (!$.isNumeric(emailOutgoingMailServerPort)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Outgoing Mail Server Port requires a number input.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (!inputIsValidAgainstRange(emailOutgoingMailServerPort, 0, 65535)) {
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Outgoing Mail Server Port is not within the range " +
                                      "of valid port numbers.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating AIRPLAY
              if ($.inArray(iosOperationConstants["AIRPLAY_OPERATION_CODE"], configuredOperations) != -1) {
                  // if AIRPLAY is configured
                  operation = iosOperationConstants["AIRPLAY_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var airplayCredentialsGridChildInputs = "div#airplay-credentials .child-input";
                  var airplayDestinationsGridChildInputs = "div#airplay-destinations .child-input";
                  if ($(airplayCredentialsGridChildInputs).length == 0 &&
                      $(airplayDestinationsGridChildInputs).length == 0) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "AirPlay settings have zero configurations attached.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      if ($(airplayCredentialsGridChildInputs).length > 0) {
                          childInputCount = 0;
                          childInputArray = [];
                          emptyChildInputCount = 0;
                          duplicatesExist = false;
                          // looping through each child input
                          $(airplayCredentialsGridChildInputs).each(function () {
                              childInputCount++;
                              if (childInputCount % 2 == 1) {
                                  // if child input is of first column
                                  childInput = $(this).val();
                                  childInputArray.push(childInput);
                                  // updating emptyChildInputCount
                                  if (!childInput) {
                                      // if child input field is empty
                                      emptyChildInputCount++;
                                  }
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more Device Names of " +
                                      "AirPlay Credentials are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              // if duplicate input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with " +
                                      "Device Names of AirPlay Credentials.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  if (continueToCheckNextInputs) {
                      if ($(airplayDestinationsGridChildInputs).length > 0) {
                          childInputArray = [];
                          emptyChildInputCount = 0;
                          invalidAgainstRegExCount = 0;
                          duplicatesExist = false;
                          // looping through each child input
                          $(airplayDestinationsGridChildInputs).each(function () {
                              childInput = $(this).val();
                              childInputArray.push(childInput);
                              // updating emptyChildInputCount
                              if (!childInput) {
                                  // if child input field is empty
                                  emptyChildInputCount++;
                              } else if (!inputIsValidAgainstRegExp(
                                      /([a-z|A-Z|0-9][a-z|A-Z|0-9][:]){5}([a-z|A-Z|0-9][a-z|A-Z|0-9])$/, childInput)) {
                                  // if child input field is invalid against RegEx
                                  invalidAgainstRegExCount++
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more AirPlay Destination fields are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (invalidAgainstRegExCount > 0) {
                              // if invalidAgainstRegEx inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more AirPlay Destination fields " +
                                      "do not fulfill expected format.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              // if duplicate input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with AirPlay Destinations.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating LDAP
              if ($.inArray(iosOperationConstants["LDAP_OPERATION_CODE"], configuredOperations) != -1) {
                  // if LDAP is configured
                  operation = iosOperationConstants["LDAP_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var ldapAccountHostname = $("input#ldap-account-hostname").val();
                  if (!ldapAccountHostname) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "LDAP Account Hostname URL is empty. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      var ldapSearchSettingsGridChildInputs = "div#ldap-search-settings .child-input";
                      if ($(ldapSearchSettingsGridChildInputs).length > 0) {
                          childInputCount = 0;
                          childInputArray = [];
                          emptyChildInputCount = 0;
                          duplicatesExist = false;
                          // looping through each child input
                          $(ldapSearchSettingsGridChildInputs).each(function () {
                              childInputCount++;
                              if (childInputCount % 3 == 2) {
                                  // if child input is of second column
                                  childInput = $(this).find("option:selected").attr("value");
                                  stringPair = "";
                                  stringPair += (childInput + " ");
                              } else if (childInputCount % 3 == 0) {
                                  // if child input is of third column
                                  childInput = $(this).val();
                                  stringPair += childInput;
                                  childInputArray.push(stringPair);
                                  // updating emptyChildInputCount
                                  if (!childInput) {
                                      // if child input field is empty
                                      emptyChildInputCount++;
                                  }
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more Search Setting Scope fields are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              // if duplicate input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with " +
                                      "Search Setting Search Base and Scope pairs.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating CALENDAR
              if ($.inArray(iosOperationConstants["CALENDAR_OPERATION_CODE"], configuredOperations) != -1) {
                  // if CALENDAR is configured
                  operation = iosOperationConstants["CALENDAR_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var calendarAccountHostname = $("input#calendar-account-hostname").val();
                  if (!calendarAccountHostname) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "Account Hostname URL is empty. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      var calendarAccountPort = $("input#calendar-account-port").val();
                      if (!calendarAccountPort) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Account Port is empty. You cannot proceed.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (!$.isNumeric(calendarAccountPort)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Account Port requires a number input.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (!inputIsValidAgainstRange(calendarAccountPort, 0, 65535)) {
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Account Port is not within the range " +
                                  "of valid port numbers.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating CALENDAR_SUBSCRIPTION
              if ($.inArray(iosOperationConstants["CALENDAR_SUBSCRIPTION_OPERATION_CODE"], configuredOperations) != -1) {
                  // if CALENDAR_SUBSCRIPTION is configured
                  operation = iosOperationConstants["CALENDAR_SUBSCRIPTION_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var calendarSubscriptionHostname = $("input#calendar-subscription-hostname").val();
                  if (!calendarSubscriptionHostname) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "Account Hostname URL is empty. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating APN
              if ($.inArray(iosOperationConstants["APN_OPERATION_CODE"], configuredOperations) != -1) {
                  // if APN is configured
                  operation = iosOperationConstants["APN_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var apnConfigurationsGridChildInputs = "div#apn-configurations .child-input";
                  if ($(apnConfigurationsGridChildInputs).length == 0) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "APN Settings have zero configurations attached.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  } else if ($(apnConfigurationsGridChildInputs).length > 0) {
                      childInputCount = 0;
                      childInputArray = [];
                      // checking empty APN field count
                      emptyChildInputCount = 0;
                      duplicatesExist = false;
                      // looping through each child input
                      $(apnConfigurationsGridChildInputs).each(function () {
                          childInputCount++;
                          //if (childInputCount % 5 == 1) {
                          // if child input is of first column
                          childInput = $(this).val();
                          childInputArray.push(childInput);
                          // updating emptyChildInputCount
                          if (!childInput) {
                              // if child input field is empty
                              emptyChildInputCount++;
                          }
                          //}
                      });
                      // checking for duplicates
                      initialChildInputArrayLength = childInputArray.length;
                      if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                          for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                              poppedChildInput = childInputArray.pop();
                              for (n = 0; n < childInputArray.length; n++) {
                                  if (poppedChildInput == childInputArray[n]) {
                                      duplicatesExist = true;
                                      break;
                                  }
                              }
                              if (duplicatesExist) {
                                  break;
                              }
                          }
                      }
                      // updating validationStatus
                      if (emptyChildInputCount > 0) {
                          // if empty child inputs are present
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "One or more APN fields of Configurations are empty.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      } else if (duplicatesExist) {
                          // if duplicate input is present
                          validationStatus = {
                              "error": true,
                              "subErrorMsg": "Duplicate values exist with " +
                                  "APN fields of Configurations.",
                              "erroneousFeature": operation
                          };
                          continueToCheckNextInputs = false;
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
              // Validating CELLULAR
              if ($.inArray(iosOperationConstants["CELLULAR_OPERATION_CODE"], configuredOperations) != -1) {
                  // if CELLULAR is configured
                  operation = iosOperationConstants["CELLULAR_OPERATION"];
                  // initializing continueToCheckNextInputs to true
                  continueToCheckNextInputs = true;
  
                  var cellularAttachAPNName = $("input#cellular-attach-apn-name").val();
                  if (!cellularAttachAPNName) {
                      validationStatus = {
                          "error": true,
                          "subErrorMsg": "Cellular Configuration Name is empty. You cannot proceed.",
                          "erroneousFeature": operation
                      };
                      continueToCheckNextInputs = false;
                  }
  
                  if (continueToCheckNextInputs) {
                      var cellularAPNConfigurationsGridChildInputs = "div#cellular-apn-configurations .child-input";
                      if ($(cellularAPNConfigurationsGridChildInputs).length > 0) {
                          childInputCount = 0;
                          childInputArray = [];
                          // checking empty APN field count
                          emptyChildInputCount = 0;
                          duplicatesExist = false;
                          // looping through each child input
                          $(cellularAPNConfigurationsGridChildInputs).each(function () {
                              childInputCount++;
                              if (childInputCount % 6 == 1) {
                                  // if child input is of first column
                                  childInput = $(this).val();
                                  childInputArray.push(childInput);
                                  // updating emptyChildInputCount
                                  if (!childInput) {
                                      // if child input field is empty
                                      emptyChildInputCount++;
                                  }
                              }
                          });
                          // checking for duplicates
                          initialChildInputArrayLength = childInputArray.length;
                          if (emptyChildInputCount == 0 && initialChildInputArrayLength > 1) {
                              for (m = 0; m < (initialChildInputArrayLength - 1); m++) {
                                  poppedChildInput = childInputArray.pop();
                                  for (n = 0; n < childInputArray.length; n++) {
                                      if (poppedChildInput == childInputArray[n]) {
                                          duplicatesExist = true;
                                          break;
                                      }
                                  }
                                  if (duplicatesExist) {
                                      break;
                                  }
                              }
                          }
                          // updating validationStatus
                          if (emptyChildInputCount > 0) {
                              // if empty child inputs are present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "One or more APN fields of APN Configurations are empty.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          } else if (duplicatesExist) {
                              // if duplicate input is present
                              validationStatus = {
                                  "error": true,
                                  "subErrorMsg": "Duplicate values exist with " +
                                      "APN fields of APN Configurations.",
                                  "erroneousFeature": operation
                              };
                              continueToCheckNextInputs = false;
                          }
                      }
                  }
  
                  // at-last, if the value of continueToCheckNextInputs is still true
                  // this means that no error is found
                  if (continueToCheckNextInputs) {
                      validationStatus = {
                          "error": false,
                          "okFeature": operation
                      };
                  }
  
                  // updating validationStatusArray with validationStatus
                  validationStatusArray.push(validationStatus);
              }
          }
      }
      // ending validation process
  
      // start taking specific notifying actions upon validation
      var wizardIsToBeContinued;
      var errorCount = 0;
      var mainErrorMsgWrapper, mainErrorMsg,
          subErrorMsgWrapper, subErrorMsg, subErrorIcon, subOkIcon, featureConfiguredIcon;
      var i;
      for (i = 0; i < validationStatusArray.length; i++) {
          validationStatus = validationStatusArray[i];
          if (validationStatus["error"]) {
              errorCount++;
              if (validationStatus["mainErrorMsg"]) {
                  mainErrorMsgWrapper = "#policy-profile-main-error-msg";
                  mainErrorMsg = mainErrorMsgWrapper + " span";
                  $(mainErrorMsg).text(validationStatus["mainErrorMsg"]);
                  $(mainErrorMsgWrapper).removeClass("hidden");
              } else if (validationStatus["subErrorMsg"]) {
                  subErrorMsgWrapper = "#" + validationStatus["erroneousFeature"] + "-feature-error-msg";
                  subErrorMsg = subErrorMsgWrapper + " span";
                  subErrorIcon = "#" + validationStatus["erroneousFeature"] + "-error";
                  subOkIcon = "#" + validationStatus["erroneousFeature"] + "-ok";
                  featureConfiguredIcon = "#" + validationStatus["erroneousFeature"] + "-configured";
                  // hiding featureConfiguredState as the first step
                  if (!$(featureConfiguredIcon).hasClass("hidden")) {
                      $(featureConfiguredIcon).addClass("hidden");
                  }
                  // updating error state and corresponding messages
                  $(subErrorMsg).text(validationStatus["subErrorMsg"]);
                  if ($(subErrorMsgWrapper).hasClass("hidden")) {
                      $(subErrorMsgWrapper).removeClass("hidden");
                  }
                  if (!$(subOkIcon).hasClass("hidden")) {
                      $(subOkIcon).addClass("hidden");
                  }
                  if ($(subErrorIcon).hasClass("hidden")) {
                      $(subErrorIcon).removeClass("hidden");
                  }
              }
          } else {
              if (validationStatus["okFeature"]) {
                  subErrorMsgWrapper = "#" + validationStatus["okFeature"] + "-feature-error-msg";
                  subErrorIcon = "#" + validationStatus["okFeature"] + "-error";
                  subOkIcon = "#" + validationStatus["okFeature"] + "-ok";
                  featureConfiguredIcon = "#" + validationStatus["okFeature"] + "-configured";
                  // hiding featureConfiguredState as the first step
                  if (!$(featureConfiguredIcon).hasClass("hidden")) {
                      $(featureConfiguredIcon).addClass("hidden");
                  }
                  // updating success state and corresponding messages
                  if (!$(subErrorMsgWrapper).hasClass("hidden")) {
                      $(subErrorMsgWrapper).addClass("hidden");
                  }
                  if (!$(subErrorIcon).hasClass("hidden")) {
                      $(subErrorIcon).addClass("hidden");
                  }
                  if ($(subOkIcon).hasClass("hidden")) {
                      $(subOkIcon).removeClass("hidden");
                  }
              }
          }
      }
  
      wizardIsToBeContinued = (errorCount == 0);
      return wizardIsToBeContinued;
  };
  
  stepForwardFrom["policy-profile"] = function () {
      policy["profile"] = operationModule.generateProfile(policy["platform"], configuredOperations);
      // updating next-page wizard title with selected platform
      $("#policy-criteria-page-wizard-title").text("ADD " + policy["platform"] + " POLICY");
      // updating ownership type options according to platform
      if (policy["platform"] == platformTypeConstants["IOS"] ||
          policy["platform"] == platformTypeConstants["WINDOWS"]) {
          var ownershipTypeSelectOptions = $("#ownership-input");
          ownershipTypeSelectOptions.empty();
          ownershipTypeSelectOptions.append($("<option></option>").
              attr("value", "BYOD").text("BYOD (Bring Your Own Device)"));
          ownershipTypeSelectOptions.attr("disabled", true);
      }
  };
  
  stepBackFrom["policy-profile"] = function () {
      // reinitialize configuredOperations
      configuredOperations = [];
      // clearing already-loaded platform specific hidden-operations html content from the relevant div
      // so that, the wrong content would not be shown at the first glance, in case
      // the user selects a different platform
      $(".wr-advance-operations").html(
              "<div class='wr-advance-operations-init'>" +
              "<br>" +
              "<i class='fw fw-settings fw-spin fw-2x'></i>" +
              "Loading Platform Features . . ." +
              "<br>" +
              "<br>" +
              "</div>"
      );
  };
  
  stepForwardFrom["policy-criteria"] = function () {
      $("input[type='radio'].select-users-radio").each(function () {
          if ($(this).is(':radio')) {
              if ($(this).is(":checked")) {
                  if ($(this).attr("id") == "users-radio-btn") {
                      policy["selectedUsers"] = $("#users-input").val();
                  } else if ($(this).attr("id") == "user-roles-radio-btn") {
                      policy["selectedUserRoles"] = $("#user-roles-input").val();
                  }
              }
          }
      });
      policy["selectedNonCompliantAction"] = $("#action-input").find(":selected").data("action");
      policy["selectedOwnership"] = $("#ownership-input").val();
      //updating next-page wizard title with selected platform
      $("#policy-naming-page-wizard-title").text("ADD " + policy["platform"] + " POLICY");
  };
  
  /**
   * Checks if provided input is valid against provided length range.
   *
   * @param input Alphanumeric or non-alphanumeric input
   * @param minLength Minimum Required Length
   * @param maxLength Maximum Required Length
   * @returns {boolean} Returns true if input matches the provided minimum length and maximum length
   */
  var inputIsValidAgainstLength = function (input, minLength, maxLength) {
      var length = input.length;
      return (length == minLength || (length > minLength && length < maxLength) || length == maxLength);
  };
  
  validateStep["policy-criteria"] = function () {
      var validationStatus = {};
      var selectedAssignees;
      var selectedField = "Role(s)";
  
      $("input[type='radio'].select-users-radio").each(function () {
          if ($(this).is(":checked")) {
              if ($(this).attr("id") == "users-radio-btn") {
                  selectedAssignees = $("#users-input").val();
                  selectedField = "User(s)";
              } else if ($(this).attr("id") == "user-roles-radio-btn") {
                  selectedAssignees = $("#user-roles-input").val();
              }
              return false;
          }
      });
  
      if (selectedAssignees) {
          validationStatus["error"] = false;
      } else {
          validationStatus["error"] = true;
          validationStatus["mainErrorMsg"] = selectedField + " is a required field. It cannot be empty";
      }
  
      var wizardIsToBeContinued;
      if (validationStatus["error"]) {
          wizardIsToBeContinued = false;
          var mainErrorMsgWrapper = "#policy-criteria-main-error-msg";
          var mainErrorMsg = mainErrorMsgWrapper + " span";
          $(mainErrorMsg).text(validationStatus["mainErrorMsg"]);
          $(mainErrorMsgWrapper).removeClass("hidden");
      } else {
          wizardIsToBeContinued = true;
      }
  
      return wizardIsToBeContinued;
  };
  
  validateStep["policy-naming"] = function () {
      var validationStatus = {};
  
      // taking values of inputs to be validated
      var policyName = $("input#policy-name-input").val();
      // starting validation process and updating validationStatus
      if (!policyName) {
          validationStatus["error"] = true;
          validationStatus["mainErrorMsg"] = "Policy name is empty. You cannot proceed.";
      } else if (!inputIsValidAgainstLength(policyName, 1, 30)) {
          validationStatus["error"] = true;
          validationStatus["mainErrorMsg"] =
              "Policy name exceeds maximum allowed length.";
      } else {
          validationStatus["error"] = false;
      }
      // ending validation process
  
      // start taking specific actions upon validation
      var wizardIsToBeContinued;
      if (validationStatus["error"]) {
          wizardIsToBeContinued = false;
          var mainErrorMsgWrapper = "#policy-naming-main-error-msg";
          var mainErrorMsg = mainErrorMsgWrapper + " span";
          $(mainErrorMsg).text(validationStatus["mainErrorMsg"]);
          $(mainErrorMsgWrapper).removeClass("hidden");
      } else {
          wizardIsToBeContinued = true;
      }
  
      return wizardIsToBeContinued;
  };
  
  validateStep["policy-platform"] = function () {
      return false;
  };
  
  validateStep["policy-naming-publish"] = function () {
      var validationStatus = {};
  
      // taking values of inputs to be validated
      var policyName = $("input#policy-name-input").val();
      // starting validation process and updating validationStatus
      if (!policyName) {
          validationStatus["error"] = true;
          validationStatus["mainErrorMsg"] = "Policy name is empty. You cannot proceed.";
      } else if (!inputIsValidAgainstLength(policyName, 1, 30)) {
          validationStatus["error"] = true;
          validationStatus["mainErrorMsg"] =
              "Policy name exceeds maximum allowed length.";
      } else {
          validationStatus["error"] = false;
      }
      // ending validation process
  
      // start taking specific actions upon validation
      var wizardIsToBeContinued;
      if (validationStatus["error"]) {
          wizardIsToBeContinued = false;
          var mainErrorMsgWrapper = "#policy-naming-main-error-msg";
          var mainErrorMsg = mainErrorMsgWrapper + " span";
          $(mainErrorMsg).text(validationStatus["mainErrorMsg"]);
          $(mainErrorMsgWrapper).removeClass("hidden");
      } else {
          wizardIsToBeContinued = true;
      }
  
      return wizardIsToBeContinued;
  };
  
  stepForwardFrom["policy-naming-publish"] = function () {
      policy["policyName"] = $("#policy-name-input").val();
      policy["description"] = $("#policy-description-input").val();
      //All data is collected. Policy can now be updated.
      savePolicy(policy, "/api/device-mgt/v1.0/policies/active-policy");
  };
  stepForwardFrom["policy-naming"] = function () {
      policy["policyName"] = $("#policy-name-input").val();
      policy["description"] = $("#policy-description-input").val();
      //All data is collected. Policy can now be updated.
      savePolicy(policy, "/api/device-mgt/v1.0/policies/inactive-policy");
  };
  
  var savePolicy = function (policy, serviceURL) {
      var profilePayloads = [];
      // traverses key by key in policy["profile"]
      var key;
      for (key in policy["profile"]) {
          if (policy["platformId"] == platformIds["WINDOWS"] &&
              key == windowsOperationConstants["PASSCODE_POLICY_OPERATION_CODE"]) {
              policy["profile"][key].enablePassword = true;
          }
          if (policy["profile"].hasOwnProperty(key)) {
              profilePayloads.push({
                  "featureCode": key,
                  "deviceTypeId": policy["platformId"],
                  "content": policy["profile"][key]
              });
          }
      }
  
      $.each(profilePayloads, function (i, item) {
          $.each(item.content, function (key, value) {
              if (!value) {
                  item.content[key] = null;
              }
          });
      });
  
      var payload = {
          "policyName": policy["policyName"],
          "description": policy["description"],
          "compliance": policy["selectedNonCompliantAction"],
          "ownershipType": policy["selectedOwnership"],
          "profile": {
              "profileName": policy["policyName"],
              "deviceType": {
                  "id": policy["platformId"]
              },
              "profileFeaturesList": profilePayloads
          }
      };
  
      if (policy["selectedUsers"]) {
          payload["users"] = policy["selectedUsers"];
      } else if (policy["selectedUserRoles"]) {
          payload["roles"] = policy["selectedUserRoles"];
      } else {
          payload["users"] = [];
          payload["roles"] = [];
      }
  
      invokerUtil.post(
          serviceURL,
          payload,
          function () {
              $(".add-policy").addClass("hidden");
              $(".policy-naming").addClass("hidden");
              $(".policy-message").removeClass("hidden");
          },
          function (data) {
          }
      );
  };
  
  // Start of HTML embedded invoke methods
  var showAdvanceOperation = function (operation, button) {
      $(button).addClass('selected');
      $(button).siblings().removeClass('selected');
      var hiddenOperation = ".wr-hidden-operations-content > div";
      $(hiddenOperation + '[data-operation="' + operation + '"]').show();
      $(hiddenOperation + '[data-operation="' + operation + '"]').siblings().hide();
  };
  
  /**
   * Method to slide down a provided pane upon provided value set.
   *
   * @param selectElement Select HTML Element to consider
   * @param paneID HTML ID of div element to slide down
   * @param valueSet Applicable Value Set
   */
  var slideDownPaneAgainstValueSet = function (selectElement, paneID, valueSet) {
      var selectedValueOnChange = $(selectElement).find("option:selected").val();
      var i, slideDownVotes = 0;
      for (i = 0; i < valueSet.length; i++) {
          if (selectedValueOnChange == valueSet[i]) {
              slideDownVotes++;
          }
      }
      var paneSelector = "#" + paneID;
      if (slideDownVotes > 0) {
          if (!$(paneSelector).hasClass("expanded")) {
              $(paneSelector).addClass("expanded");
          }
          $(paneSelector).slideDown();
      } else {
          if ($(paneSelector).hasClass("expanded")) {
              $(paneSelector).removeClass("expanded");
          }
          $(paneSelector).slideUp();
          /** now follows the code to reinitialize all inputs of the slidable pane */
              // reinitializing input fields into the defaults
          $(paneSelector + " input").each(
              function () {
                  if ($(this).is("input:text")) {
                      $(this).val($(this).data("default"));
                  } else if ($(this).is("input:password")) {
                      $(this).val("");
                  } else if ($(this).is("input:checkbox")) {
                      $(this).prop("checked", $(this).data("default"));
                      // if this checkbox is the parent input of a grouped-input
                      if ($(this).hasClass("parent-input")) {
                          var groupedInput = $(this).parent().parent().parent();
                          updateGroupedInputVisibility(groupedInput);
                      }
                  }
              }
          );
          // reinitializing select fields into the defaults
          $(paneSelector + " select").each(
              function () {
                  var defaultOption = $(this).data("default");
                  $("option:eq(" + defaultOption + ")", this).prop("selected", "selected");
              }
          );
          // collapsing expanded-panes (upon the selection of html-select-options) if any
          $(paneSelector + " .expanded").each(
              function () {
                  if ($(this).hasClass("expanded")) {
                      $(this).removeClass("expanded");
                  }
                  $(this).slideUp();
              }
          );
          // removing all entries of grid-input elements if exist
          $(paneSelector + " .grouped-array-input").each(
              function () {
                  var gridInputs = $(this).find("[data-add-form-clone]");
                  if (gridInputs.length > 0) {
                      gridInputs.remove();
                  }
                  var helpTexts = $(this).find("[data-help-text=add-form]");
                  if (helpTexts.length > 0) {
                      helpTexts.show();
                  }
              }
          );
      }
  };
  // End of HTML embedded invoke methods
  
  
  // Start of functions related to grid-input-view
  
  /**
   * Method to set count id to cloned elements.
   * @param {object} addFormContainer
   */
  var setId = function (addFormContainer) {
      $(addFormContainer).find("[data-add-form-clone]").each(function (i) {
          $(this).attr("id", $(this).attr("data-add-form-clone").slice(1) + "-" + (i + 1));
          if ($(this).find(".index").length > 0) {
              $(this).find(".index").html(i + 1);
          }
      });
  };
  
  /**
   * Method to set count id to cloned elements.
   * @param {object} addFormContainer
   */
  var showHideHelpText = function (addFormContainer) {
      var helpText = "[data-help-text=add-form]";
      if ($(addFormContainer).find("[data-add-form-clone]").length > 0) {
          $(addFormContainer).find(helpText).hide();
      } else {
          $(addFormContainer).find(helpText).show();
      }
  };
  
  function formatRepo(user) {
      if (user.loading) {
          return user.text;
      }
      if (!user.username) {
          return;
      }
      var markup = '<div class="clearfix">' +
          '<div clas="col-sm-8">' +
          '<div class="clearfix">' +
          '<div class="col-sm-3">' + user.username + '</div>';
      if (user.firstname) {
          markup += '<div class="col-sm-3"><i class="fa fa-code-fork"></i> ' + user.firstname + '</div>';
      }
      if (user.emailAddress) {
          markup += '<div class="col-sm-2"><i class="fa fa-star"></i> ' + user.emailAddress + '</div></div>';
      }
      markup += '</div></div>';
      return markup;
  }
  
  function formatRepoSelection(user) {
      return user.username || user.text;
  }
  
  function promptErrorPolicyPlatform(errorMsg) {
      var mainErrorMsgWrapper = "#policy-platform-main-error-msg";
      var mainErrorMsg = mainErrorMsgWrapper + " span";
      $(mainErrorMsg).text(errorMsg);
      $(mainErrorMsgWrapper).removeClass("hidden");
  }
  
  // End of functions related to grid-input-view
  
  
  $(document).ready(function () {
      $("#users-input").select2({
          multiple: true,
          tags: false,
          ajax: {
              url: window.location.origin + "/devicemgt/api/invoker/execute/",
              method: "POST",
              dataType: 'json',
              delay: 250,
              id: function (user) {
                  return user.username;
              },
              data: function (params) {
                  var postData = {};
                  postData.actionMethod = "GET";
                  postData.actionUrl = "/api/device-mgt/v1.0/users/search/usernames";
                  postData.actionPayload = JSON.stringify({
                      filter: params.term, // search term
                      page: params.page
                  });
  
                  return JSON.stringify(postData);
              },
              processResults: function (data, page) {
                  var newData = [];
                  $.each(data.responseContent, function (index, value) {
                      value.id = value.username;
                      newData.push(value);
                  });
                  return {
                      results: newData
                  };
              },
              cache: true
          },
          escapeMarkup: function (markup) {
              return markup;
          }, // let our custom formatter work
          minimumInputLength: 1,
          templateResult: formatRepo, // omitted for brevity, see the source of this page
          templateSelection: formatRepoSelection // omitted for brevity, see the source of this page
      });
  
      $("#loading-content").remove();
      $(".policy-platform").removeClass("hidden");
      // Adding initial state of wizard-steps.
      $("#policy-profile-wizard-steps").html($(".wr-steps").html());
  
      policy["platform"] = $("#platform").data("platform");
      policy["platformId"] = $("#platform").data("platform-id");
      // updating next-page wizard title with selected platform
      $("#policy-profile-page-wizard-title").text("ADD " + policy["platform"] + " POLICY");
  
      var deviceType = policy["platform"];
      var hiddenOperationsByDeviceType = $("#hidden-operations-" + deviceType);
      var hiddenOperationsByDeviceTypeCacheKey = deviceType + "HiddenOperations";
      var hiddenOperationsByDeviceTypeSrc = hiddenOperationsByDeviceType.attr("src");
  
      setTimeout(
              function () {
                  $.template(hiddenOperationsByDeviceTypeCacheKey, hiddenOperationsByDeviceTypeSrc, function (template) {
                      var content = template();
                      $(".wr-advance-operations").html(content);
                      $(".wr-advance-operations li.grouped-input").each(function () {
                          updateGroupedInputVisibility(this);
                      });
                  });
              },
              250 // time delayed for the execution of above function, 250 milliseconds
      );
  
      $("select.select2[multiple=multiple]").select2({
          "tags": false
      });
  
      $("#users-select-field").hide();
      $("#user-roles-select-field").show();
  
      $("input[type='radio'].select-users-radio").change(function () {
          if ($("#users-radio-btn").is(":checked")) {
              $("#user-roles-select-field").hide();
              $("#users-select-field").show();
          }
          if ($("#user-roles-radio-btn").is(":checked")) {
              $("#users-select-field").hide();
              $("#user-roles-select-field").show();
          }
      });
  
      // Support for special input type "ANY" on user(s) & user-role(s) selection
      $("#user-roles-input").select2({
          "tags": false
      }).on("select2:select", function (e) {
          if (e.params.data.id == "ANY") {
              $(this).val("ANY").trigger("change");
          } else {
              $("option[value=ANY]", this).prop("selected", false).parent().trigger("change");
          }
      });
  
      // Maintains an array of configured features of the profile
      var advanceOperations = ".wr-advance-operations";
      $(advanceOperations).on("click", ".wr-input-control.switch", function (event) {
          var operationCode = $(this).parents(".operation-data").data("operation-code");
          var operation = $(this).parents(".operation-data").data("operation");
          var operationDataWrapper = $(this).data("target");
          // prevents event bubbling by figuring out what element it's being called from.
          if (event.target.tagName == "INPUT") {
              var featureConfiguredIcon;
              if ($("input[type='checkbox']", this).is(":checked")) {
                  configuredOperations.push(operationCode);
                  // when a feature is enabled, if "zero-configured-features" msg is available, hide that.
                  var zeroConfiguredOperationsErrorMsg = "#policy-profile-main-error-msg";
                  if (!$(zeroConfiguredOperationsErrorMsg).hasClass("hidden")) {
                      $(zeroConfiguredOperationsErrorMsg).addClass("hidden");
                  }
                  // add configured-state-icon to the feature
                  featureConfiguredIcon = "#" + operation + "-configured";
                  if ($(featureConfiguredIcon).hasClass("hidden")) {
                      $(featureConfiguredIcon).removeClass("hidden");
                  }
              } else {
                  //splicing the array if operation is present.
                  var index = $.inArray(operationCode, configuredOperations);
                  if (index != -1) {
                      configuredOperations.splice(index, 1);
                  }
                  // when a feature is disabled, clearing all its current configured, error or success states
                  var subErrorMsgWrapper = "#" + operation + "-feature-error-msg";
                  var subErrorIcon = "#" + operation + "-error";
                  var subOkIcon = "#" + operation + "-ok";
                  featureConfiguredIcon = "#" + operation + "-configured";
  
                  if (!$(subErrorMsgWrapper).hasClass("hidden")) {
                      $(subErrorMsgWrapper).addClass("hidden");
                  }
                  if (!$(subErrorIcon).hasClass("hidden")) {
                      $(subErrorIcon).addClass("hidden");
                  }
                  if (!$(subOkIcon).hasClass("hidden")) {
                      $(subOkIcon).addClass("hidden");
                  }
                  if (!$(featureConfiguredIcon).hasClass("hidden")) {
                      $(featureConfiguredIcon).addClass("hidden");
                  }
                  // reinitializing input fields into the defaults
                  $(operationDataWrapper + " input").each(
                      function () {
                          if ($(this).is("input:text")) {
                              $(this).val($(this).data("default"));
                          } else if ($(this).is("input:password")) {
                              $(this).val("");
                          } else if ($(this).is("input:checkbox")) {
                              $(this).prop("checked", $(this).data("default"));
                              // if this checkbox is the parent input of a grouped-input
                              if ($(this).hasClass("parent-input")) {
                                  var groupedInput = $(this).parent().parent().parent();
                                  updateGroupedInputVisibility(groupedInput);
                              }
                          }
                      }
                  );
                  // reinitializing select fields into the defaults
                  $(operationDataWrapper + " select").each(
                      function () {
                          var defaultOption = $(this).data("default");
                          $("option:eq(" + defaultOption + ")", this).prop("selected", "selected");
                      }
                  );
                  // collapsing expanded-panes (upon the selection of html-select-options) if any
                  $(operationDataWrapper + " .expanded").each(
                      function () {
                          if ($(this).hasClass("expanded")) {
                              $(this).removeClass("expanded");
                          }
                          $(this).slideUp();
                      }
                  );
                  // removing all entries of grid-input elements if exist
                  $(operationDataWrapper + " .grouped-array-input").each(
                      function () {
                          var gridInputs = $(this).find("[data-add-form-clone]");
                          if (gridInputs.length > 0) {
                              gridInputs.remove();
                          }
                          var helpTexts = $(this).find("[data-help-text=add-form]");
                          if (helpTexts.length > 0) {
                              helpTexts.show();
                          }
                      }
                  );
              }
          }
      });
  
      // adding support for cloning multiple profiles per feature with cloneable class definitions
      $(advanceOperations).on("click", ".multi-view.add.enabled", function () {
          // get a copy of .cloneable and create new .cloned div element
          var cloned = "<div class='cloned'><hr>" + $(".cloneable", $(this).parent().parent()).html() + "</div>";
          // append newly created .cloned div element to panel-body
          $(this).parent().parent().append(cloned);
          // enable remove action of newly cloned div element
          $(".cloned", $(this).parent().parent()).each(
              function () {
                  if ($(".multi-view.remove", this).hasClass("disabled")) {
                      $(".multi-view.remove", this).removeClass("disabled");
                  }
                  if (!$(".multi-view.remove", this).hasClass("enabled")) {
                      $(".multi-view.remove", this).addClass("enabled");
                  }
              }
          );
      });
  
      $(advanceOperations).on("click", ".multi-view.remove.enabled", function () {
          $(this).parent().remove();
      });
  
      // enabling or disabling grouped-input based on the status of a parent check-box
      $(advanceOperations).on("click", ".grouped-input", function () {
          updateGroupedInputVisibility(this);
      });
  
      // add form entry click function for grid inputs
      $(advanceOperations).on("click", "[data-click-event=add-form]", function () {
          var addFormContainer = $("[data-add-form-container=" + $(this).attr("href") + "]");
          var clonedForm = $("[data-add-form=" + $(this).attr("href") + "]").clone().
              find("[data-add-form-element=clone]").attr("data-add-form-clone", $(this).attr("href"));
  
          // adding class .child-input to capture text-input-array-values
          $("input, select", clonedForm).addClass("child-input");
  
          $(addFormContainer).append(clonedForm);
          setId(addFormContainer);
          showHideHelpText(addFormContainer);
      });
  
      // remove form entry click function for grid inputs
      $(advanceOperations).on("click", "[data-click-event=remove-form]", function () {
          var addFormContainer = $("[data-add-form-container=" + $(this).attr("href") + "]");
  
          $(this).closest("[data-add-form-element=clone]").remove();
          setId(addFormContainer);
          showHideHelpText(addFormContainer);
      });
  
      $(".wizard-stepper").click(function () {
          // button clicked here can be either a continue button or a back button.
          var currentStep = $(this).data("current");
          var validationIsRequired = $(this).data("validate");
          var wizardIsToBeContinued;
  
          if (validationIsRequired) {
              wizardIsToBeContinued = validateStep[currentStep]();
          } else {
              wizardIsToBeContinued = true;
          }
  
          if (wizardIsToBeContinued) {
              // When moving back and forth, following code segment will
              // remove if there are any visible error-messages.
              var errorMsgWrappers = ".alert.alert-danger";
              $(errorMsgWrappers).each(
                  function () {
                      if (!$(this).hasClass("hidden")) {
                          $(this).addClass("hidden");
                      }
                  }
              );
  
              var nextStep = $(this).data("next");
              var isBackBtn = $(this).data("is-back-btn");
  
              // if current button is a continuation...
              if (!isBackBtn) {
                  // initiate stepForwardFrom[*] functions to gather form data.
                  if (stepForwardFrom[currentStep]) {
                      stepForwardFrom[currentStep](this);
                  }
              } else {
                  // initiate stepBackFrom[*] functions to rollback.
                  if (stepBackFrom[currentStep]) {
                      stepBackFrom[currentStep]();
                  }
              }
  
              // following step occurs only at the last stage of the wizard.
              if (!nextStep) {
                  window.location.href = $(this).data("direct");
              }
  
              // updating next wizard step as current.
              $(".itm-wiz").each(function () {
                  var step = $(this).data("step");
                  if (step == nextStep) {
                      $(this).addClass("itm-wiz-current");
                  } else {
                      $(this).removeClass("itm-wiz-current");
                  }
              });
  
              // adding next update of wizard-steps.
              $("#" + nextStep + "-wizard-steps").html($(".wr-steps").html());
  
              // hiding current section of the wizard and showing next section.
              $("." + currentStep).addClass("hidden");
              $("." + nextStep).removeClass("hidden");
          }
      });
  });