// JScript File

//-----------------------------------------------------------------------------
// Module:        Forms.js
// Contains form helper methods.
//-----------------------------------------------------------------------------

var validationFields="99999"; 

//////////////////////////////////////////
//
// ConfirmDelete()
//
// Displays a delete confirmation dialog box. 
//
//////////////////////////////////////////
function ConfirmDelete()
{
  bStatus = false;

  if (confirm("Do you wish to delete the selected entry ?") == true)
  {
    bStatus = true;
  }

  return bStatus;
}

//////////////////////////////////////////
//
// SubmitForm(formName)
//
// Validate and submit the specified form.
//
// formName - The name of the form to submit.
//
//////////////////////////////////////////
function SubmitForm(formName)
{
  if (ValidateForm(formName) == true)
  {
    document[formName].submit();
  }
}

//////////////////////////////////////////
//
// ResetForm(formName)
//
// Resets the specified form.
//
// formName - The name of the form to reset.
//
//////////////////////////////////////////
function ResetForm(formName)
{
  if (document[formName] != null)
  {
    document[formName].reset();

    for (iIdx = 0; iIdx < document[formName].elements.length; iIdx++)
    {
      var elem = document[formName].elements[iIdx];
      if (elem.type != "hidden")
      {
        if (elem.type != "radio")
        {
          if (elem.name != "maxRows")
          {
            elem.value = "";
          }
        }
      }
    }
  }
}

//////////////////////////////////////////
//
// SubmitForm(formName, func)
//
// Validate and submit the specified form.
//
// formName - The name of the form to submit.
// func     - The function to call if the form validation fails.
//
//////////////////////////////////////////
function SubmitForm(formName, func)
{
  if (ValidateForm(formName) == true)
  {
    document[formName].submit();
  }
  else
  {
    func;
  }
}

//////////////////////////////////////////
//
// Check for selecting an option from drop down list
//
//
//////////////////////////////////////////
function CheckDDList(listName)
{
    var ret = false;
    var obj = document.getElementById(listName);
    if( obj.selectedIndex > 0 )
        ret = true;
    else
        alert( "Please select a program." );
    return ret;
}

function CheckList(listName)
{
    var ret = false;
    var obj = document.getElementById(listName);
    for( var i=0; i < obj.options.length; i++ )
    {
        if( obj.options[i].selected == true )
            {
                ret = true;
                break;
            }
    }
    if( ret == false )
        alert( "You haven't selected any " + obj.label + "." );
    return ret;
}

function setVF( validationFieldsValue )
{
    validationFields = validationFieldsValue;
    return true;
}

//////////////////////////////////////////
//
// ValidateForm(formName)
//
// Validate the specified form.
//
// Validation elements:
//   - required        (input required - yes or no)
//   - datatype        (form field datatype - string, date, numeric, emailaddress)
//   - negativeallowed (determines whether the data can be a negative number - yes or no)
//   - dataformat      (field of whether to allowdecimals - allowdecimals)
//   - label           (user defined form field label)
//   - lower           (used to validate a lower numeric range)
//   - upper           (used to validate an upper numeric range)
//   - conditional     (used to validate a conditional required field)
//   - disallowchars   (input required, format: char1char2char3... [ie: ^/\"'`)
//   - keepdisabled    (skip requirements / validation and keep the element disabled)
//   - wraplabel       (wrap the label in quotes - yes or no)
//   - sameAs          (validates that two specific fields have the same value)
//   - numeric         (validates numeric fields - negative allowed, positive required, allow decimals)
//   - compare         (compare one field value to another)
//   - compareto       (field to compare to)
//
// formName - The name of the form to submit.
//
//////////////////////////////////////////
function ValidateForm(formName)
{
  var bStatus = true;
  for (var idx = 0; idx < document[formName].elements.length; idx++)
  {
    var elem = document[formName].elements[idx];
    if( (elem.label!=null) && (validationFields.indexOf( elem.label ) > -1) )
    {

    //    
    if (elem.required == null)
    {
        elem.required = "no";      
    }
    
    if (elem.disallowchars == null)
    {
       elem.disallowchars = "";      
    }
    
    if (elem.conditional == null)
    {
       elem.conditional = "";  
    }
    
    if (elem.sameAs == null)
    {
       elem.sameAs = "";  
    }

    if (elem.label == null)
    {
       elem.label = elem.name;      
    }
    
    if (elem.isDisabled == true)
    {
      elem.keepdisabled = true;      
    }
    else
    {
      elem.keepdisabled = false;      
    }

    if (elem.datatype == null)
    {
       elem.datatype = "string";      
    }
    
    if (elem.dataformat == null)
    {
       elem.dataformat = "";      
    }
    
    if (elem.wraplabel == null)
    {
       elem.wraplabel = "yes";      
    }  
    
    if (elem.negativeallowed == null)
    {
       elem.negativeallowed = "no";      
    }        

    //
    // Validate required input
    //
    

    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.required == "yes")
      {
        if (elem.value == "")
        {
          alert(elem.label + " is required.");
          try
            {
              elem.focus();
            }
          catch (hErr)
            {
            };
          bStatus = false;
          idx = document[formName].elements.length;
        }
      }
    }

    //
    // Disallow characters
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if ((elem.disallowchars != "") & (elem.value != ""))
      {
        var inputValue = elem.value;
        var illegalCharacters = elem.disallowchars;
        var illegalCharactersLength = elem.disallowchars.length;
       	for (i = 0; i < illegalCharactersLength; i++)
       	{
       	  illegalCharacter = illegalCharacters.charAt(i);
       	  if (inputValue.indexOf(illegalCharacter) != -1)
       	  {
       	    illegalCharacterAlert = "'" + elem.label + "' cannot contain any of the following characters: \n      ";
       	    for (j = 0; j < illegalCharactersLength; j++)
       	    {
       	      illegalCharacterAlert = illegalCharacterAlert + illegalCharacters.charAt(j) + "   ";
       	    }
       	  	alert(illegalCharacterAlert);
    	      i = illegalCharactersLength;
    	      bStatus = false;
       	  }
       	}
      }
    }
    
    //
    // Validate conditional required input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.conditional != "")
      {
        if (elem.value != "")
        {
          var conditionalName = elem.conditional;

          if (document[formName][conditionalName].value == "")
          {
            alert(document[formName][conditionalName].label + " is required.");
            document[formName][conditionalName].focus();

            bStatus = false;
            idx = document[formName].elements.length;
          }
        }
      }
    }

    //
    // Validate sameAs required input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.sameAs != "")
      {
        if (elem.value != "")
        {
          var sameAsName = elem.sameAs;

          if ( elem.value != document[formName][sameAsName].value )
          {
            alert(elem.label + " and " + document[formName][sameAsName].label + " must be the same value.");
            document[formName][sameAsName].focus();

            bStatus = false;
            idx = document[formName].elements.length;
          }
        }
      }
    }

    //
    // Validate alphanumeric input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "alphanumeric" && elem.value != "")
      {
         pattern1 =/^[\da-z]+$/i;
          var valueToTest = elem.value;
            
          if(pattern1.test(valueToTest) == false)
          {
             alert(elem.label + " must contain letters and numbers only.");

             try
             {
               elem.focus();
             }
             catch (hErr)
             {
               
             }

             bStatus = false;
             idx = document[formName].elements.length;
          }
        }
     }
      
    //
    // Validate numeric input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "numeric" && elem.value != "")
      {
        // Test the value (regardless of the actual value)
        if (elem.negativeallowed == "yes")
        {
          // The value can be negative

          pattern1 = /^[-0-9]*\.?[0-9]*$/;
          var valueToTest = elem.value;

          if(pattern1.test(valueToTest) == false)
          {
             alert(elem.label + " must be a numeric value.");

             try
             {
               elem.focus();
             }
             catch (hErr)
             {
             }

             bStatus = false;
             idx = document[formName].elements.length;
          }
        }
        else
        {  
          // The value must be positive

          pattern1 = /^[0-9]*\.?[0-9]*$/;
          var valueToTest = elem.value;

          if(pattern1.test(valueToTest) == false)
          {
             alert(elem.label + " must be a positive numeric value.");

             try
             {
               elem.focus();
             }
             catch (hErr)
             {
             }

             bStatus = false;
             idx = document[formName].elements.length;
          }
        }

        if (bStatus == true)
        {  
          // Test if the number can be a decimal number
          if (elem.dataformat != "allowdecimals")
          {
            pattern2 = /^[-0-9]*$/;

            if(pattern2.test(valueToTest)==false)
            {
              alert(elem.label + " must be an integer value.");

              try
              {
                elem.focus();
              }
              catch (hErr)
              {
              }
  
              bStatus = false;
              idx = document[formName].elements.length;
            }
          }
        }
      }
    }

    //
    // Validate numeric range input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "numeric" && elem.lower != null && elem.upper != null && elem.value != "")
      {
        var val = Number(elem.value);
        var lower = Number(elem.lower);
        var upper = Number(elem.upper);

        if ((val < lower) || (val > upper))
        {
          if (elem.wraplabel == "yes")
          {
            alert(elem.label + " must be between " + elem.lower + " and " + elem.upper + ".");
          }
          else
          {
            alert(elem.label + " must be between " + elem.lower + " and " + elem.upper + ".");
          }

          try
           {
             elem.focus();
           }
          catch (hErr)
           {
           };

          bStatus = false;
          idx = document[formName].elements.length;
        }
      }
    }

    //
    // Validate date input
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "date" && elem.value != "")
      {
        if (ValidateDate(elem.value) != 0)
        {
          alert(elem.label + " is not a valid date.");
          try
           {
             elem.focus();
           }
          catch (hErr)
           {
           };

          bStatus = false;
          idx = document[formName].elements.length;
        }
        else
        {
          if (elem.keepdisabled == false) elem.disabled = false;
        }
      }
    }     

    //
    // Validate email address
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "emailaddress" && elem.value != "")
      {
        if (ValidateEmailAddress(elem.value) != 0)
        {
          alert(elem.value + " does not appear to be a valid email address.");
          try
           {
             elem.focus();
           }
          catch (hErr)
           {
           };

          bStatus = false;
          idx = document[formName].elements.length;
        }
        else
        {
          if (elem.keepdisabled == false) elem.disabled = false;
        }
      }
    }     

    //
    // Validate color
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.datatype == "color" && elem.value != "")
      {
				if ((elem.value.indexOf("#") == -1) || (elem.value.length < 7))
				{
					alert(elem.label + " must be a properly formatted hexidecimal color string. (ie: #xxxxxx)");
          bStatus = false;
          idx = document[formName].elements.length;
        }
        else
        {
          if (elem.keepdisabled == false) elem.disabled = false;
        }
      }
    }     

    //
    // Comparison
    //
    if ((bStatus == true) && (elem.keepdisabled == false))
    {
      if (elem.compare == "true" && elem.value != "")
      {
         var firstValue = elem;
         var secondValue = document.getElementById(elem.compareto);
         
         if (elem.datatype == "date")
         { 
           var iFirstValue = Date.parse(firstValue.value);
           var iSecondValue = Date.parse(secondValue.value);   
         }
         else if (elem.datatype == "numeric")
         {
           var iFirstValue = firstValue.value;
           var iSecondValue = secondValue.value;
         }

         if (parseInt(iSecondValue) > parseInt(iFirstValue))
         {
           alert(secondValue.label + " cannot be greater than " + firstValue.label + ".");
           try
           {
             elem.focus();
           }
           catch (hErr)
           {
           };
           bStatus = false;
         }
      }
    }   
    
    } // indexOf  

  }

  return bStatus;
}

//////////////////////////////////////////
//
// ValidateDate(dateValue)
//
// Validate the specified date.
//
// dateValue - The date to validate.
//
//////////////////////////////////////////
function ValidateDate(dateValue)
{
  var checkstr = "0123456789";
  var dateTemp = "";
  var seperator = "/";
  var day = 0;
  var month = 0;
  var year = 0;
  var leap = 0;
  var err = 0;
  var i;
  err = 0;

  dateTemp = Date.parse(dateValue)

  if (isNaN(dateTemp) || dateTemp == "")
  {
    return -1;
  }

  dateTemp = "";
 
  /* Delete all chars except 0..9 */
  for (i = 0; i < dateValue.length; i++)
  {
    if (checkstr.indexOf(dateValue.substr(i,1)) >= 0)
    {
      dateTemp = dateTemp + dateValue.substr(i,1);
    }
  }

  dateValue = dateTemp;

  /* Always change date to 8 digits - string*/
  /* If year is entered as 2-digit / always assume 20xx */
  if (dateValue.length == 6)
  {
    dateValue = dateValue.substr(0,4) + '20' + dateValue.substr(4,2);
  }
  
  if (dateValue.length != 8)
  {
    err = 19;
  }

  /* Year is wrong if year = 0000 */
  year = dateValue.substr(4,4);
   
  if (year == 0)
  {
    err = 20;
  }

  /* Validation of month */
  month = dateValue.substr(0,2);

  if ((month < 1) || (month > 12))
  {
    err = 21;
  }

  /* Validation of day */
  day = dateValue.substr(2,2);

  if (day < 1)
  {
    err = 22;
  }

  /* Validation leap-year / february / day */
  if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0))
  {
    leap = 1;
  }

  if ((month == 2) && (leap == 1) && (day > 29))
  {
    err = 23;
  }

  if ((month == 2) && (leap != 1) && (day > 28))
  {
    err = 24;
  }

   /* Validation of other months */
  if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12")))
  {
    err = 25;
  }

  if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11")))
  {
    err = 26;
  }

  /* if 00 ist entered, no error, deleting the entry */
  if ((day == 0) && (month == 0) && (year == 00))
  {
    err = 0; day = ""; month = ""; year = ""; seperator = "";
  }

  return err
}

//////////////////////////////////////////
//
// ValidateEmailAddress(emailAddress)
//
// Validate the specified email address.
//
// emailAddress - The email address to validate.
//
//////////////////////////////////////////
function ValidateEmailAddress(emailAddress)
{
  err = 0;

  if (emailAddress.indexOf('@') == -1)
  {
    return -1;
  }

  if (emailAddress.indexOf('.') == -1)
  {
    return -1;
  }

  return err;
}

//////////////////////////////////////////
//
// InitForm()
//
// Initialize the specified form with default values.
//
//
//////////////////////////////////////////
function InitForm(url, formName)
{
//  var queryParams = "rangetype|0|interval|2|maxRows|5|sessionStatusId|2";

  var idx = 0;
  var paramName = "";
  var paramValue = "";

  var xml = RequestXML(url);

  var queryParams = GetElement(xml, "query-text");

  if ( (queryParams != "") && (queryParams != null) )
  {
    var queryParamsArray = queryParams.split("|");

    while (idx < queryParamsArray.length)
    {
      paramName = queryParamsArray[idx];
      paramValue = queryParamsArray[idx + 1];
      
      if (paramName == "period")
      {
         var period = document.getElementById("period");
         iselect = queryParamsArray[idx + 1];
         iselect++;
         period.options[iselect].selected = true;
      }
      else if (paramName == "rangetype")
      {
         if (paramValue == 0)
         {
            var rangetype0 = document.getElementById("rangetype0");

            if (rangetype0 != null)
            {
               rangetype0.checked = true;
            }
         }
         else if (paramValue == 1)
         {
            var rangetype1 = document.getElementById("rangetype1");

            if (rangetype1 != null)
            {
               rangetype1.checked = true;
            }
         }
      }
      else
      {
         document[formName][paramName].value = paramValue;
      }
      idx += 2;
    }
  }
}

//////////////////////////////////////////
//
// calculateMargin()
//
// calculates the subscriber cost from the program cost + markup
//  cost * 1.50
//
//
//////////////////////////////////////////
function calculateMargin(txtCost, txtSubscriberCost)
{
    if (txtCost.value != ""  && parseFloat(txtCost.value) > 0)
    {
        var cost = parseFloat(txtCost.value);
        var subscriberCost = cost * 1.5;
        txtSubscriberCost.value = subscriberCost;
        
    }    
}