// JScript File
// Handle validators

var skipValidation;
var fdv_validatedControls;
var fdv_alertError;

function fdv_getValidatedControls()
{
    if (!fdv_validatedControls) fdv_validatedControls = new Array();
    return fdv_validatedControls;
}

function fdv_getValidatedControl(id)
{
    var vc = fdv_getValidatedControls();

    for (var i=0;i<vc.length;i++)
        if (vc[i].id == id) return vc[i];
    return null;
}

function fdv_validatedControl(id)
{
    if (id) this.id = id;
    else id = "";
    this.control = document.getElementById(this.id);
    this.validators = new Array();
}

fdv_validatedControl.prototype.getValidatorByType = function(type)
{
    var v = this.validators;
    
    for (var i=0;i<v.length;i++) if (v[i].type == type) return v[i];
    return null;
}

function fdv_validator(id, type)
{
    if (id) this.id = id;
    else id = "";
    if (type) this.type = type;
    else type = "";
    this.validatorMessage = document.getElementById(this.id);
    this.funcName = "";
    this.compareTo = "";
    this.isValid = true;
}

function fdv_addValidator(id, controlId, type)
{
    var validator;
    var vc = fdv_getValidatedControls();
    var valCtl = fdv_getValidatedControl(controlId);

    if (!valCtl)
    {
        valCtl = new fdv_validatedControl(controlId);
        vc.push(valCtl);
    }
    validator = new fdv_validator(id, type);
    valCtl.validators.push(validator);
    return validator;
}

function fdv_pageIsValid(clientId)
{
    var valCtl, validator;
    var vc = fdv_getValidatedControls();
    
    for (var i=0;i<vc;i++)
    {
        valCtl = vc[i];
        if (!clientId || (valCtl.id.indexOf(clientId) == 0))
        {
            for (var j=0;j<valCtl.validators.length;j++)
            {
                validator = valCtl.validators[j];
                if (!validator.isValid) return false;
            }
        }
    }
    return true;
}

function fdv_validate(notOKMessage, runMeFirst)
{
    if (!runMeFirst || eval(runMeFirst + "()"))
    {
      var allOK = true;

      if (!skipValidation) {
        var isValid;
        var ctl, valCtl, validator;
        var vc = fdv_getValidatedControls();

        for (var i = 0; i < vc.length; i++) {
          valCtl = vc[i];
          ctl = valCtl.control;
          if (ctl == null || ctl.parentNode == null) continue;
          if (fdv_displayed(ctl)) for (var j = 0; j < valCtl.validators.length; j++) {
            validator = valCtl.validators[j];
            switch (validator.type) {
              case "compare":
                isValid = fdv_comp(ctl, validator);
                break;
              case "custom":
                isValid = fdv_custom(ctl, validator);
                break;
              case "mustBeNumeric":
                isValid = fdv_mustBeNumeric(ctl, validator);
                break;
              case "requiredField":
                isValid = fdv_rqf(ctl, validator);
                break;
            }
            if (allOK) allOK = isValid;
            if (!isValid) break;
          }
        }
      }
      if (allOK) allOK = validateFileExtensions();
      if (!allOK && (typeof(notOKMessage) == "string")) alert(notOKMessage);
      return allOK;
    }
    return false;
}

function fdv_displayed(ctl)
{
    var displayed = (ctl && (ctl.style.display != "none") && (ctl.style.visibility != "hidden"));
    
    if (displayed)
    {
        var parent = ctl.parentNode;
        
        displayed = (parent != null);
        if (displayed) while (parent && parent.nodeType == 1)
        {
            displayed = ((parent.style.display != "none") && (parent.style.visibility != "hidden"));
            if (!displayed) break;
            parent = parent.parentNode;
        }
    }
    return displayed;
}

function fdv_onblur(evt)
{
    var src = getSrcElement(evt);
    
    skipValidation = false;
    if (src && src.id)
    {
        var valCtl = fdv_getValidatedControl(src.id);
        
        if (valCtl)
        {
            var isValid, validator;
            
            for (var i=0;i<valCtl.validators.length;i++)
            {
                validator = valCtl.validators[i];
                switch (validator.type)
                {
                    case "compare":
                        isValid = fdv_comp(valCtl.control, validator);
                        break;
                    case "custom":
                        isValid = fdv_custom(valCtl.control, validator);
                        break;
                    case "mustBeNumeric":
                        isValid = fdv_mustBeNumeric(valCtl.control, validator);
                        break;
                    case "requiredField":
                        isValid = fdv_rqf(valCtl.control, validator);
                        break;
                }
                if (!isValid) return false;
            }
        }
    }
    return true;
}

function displayValidatorMessage(validator, isValid)
{
    if (validator.validatorMessage)
    {
        if (fdv_alertError)
        {
            if (!isValid) alert(validator.validatorMessage.innerHTML);
        }
        else
        {
            var child, dispMsgExist;
            var td = validator.validatorMessage.parentNode;
            var tr = validator.validatorMessage.parentNode.parentNode;
            
            if (isValid) validator.validatorMessage.style.display = "none";
            else validator.validatorMessage.style.display = "";
            child = getChildNode(td, 0);
            dispMsgExist = !isValid;
            while ((child != null) && !dispMsgExist)
            {
                dispMsgExist = (child.style.display != "none");
                child = getNextSibling(child);
            }
            if (dispMsgExist) tr.style.display = "";
            else tr.style.display = "none";
        }
    }
}

// Required field validators

function fdv_rqf(ctl, validator)
{
    if (ctl)
    {
        var isValid = true;
        var isChecked = false;
        var tagNm = _tagName(ctl);
        
        if (tagNm == "table")
        {
            var row, cell, child, typ;
            
            for (var i=0;i<ctl.rows.length;i++)
            {
                row = ctl.rows[i];
                for (var j=0;j<row.cells.length;j++)
                {
                    cell = row.cells[j];
                    child = getChildNode(cell, 0);
                    if (child)
                    {
                        tagNm = _tagName(child);
                        if (tagNm == "input")
                        {
                            typ = child.type.toLowerCase();
                            if ((typ == "radio") || (typ == "checkbox"))
                            {
                                isChecked = isChecked || child.checked;
                                isValid = false;
                                if (isChecked) break;
                            }
                        }
                        else
                        {
                          if (tagNm == "select") isValid = (child.value != "-1");
                          else if (tagNm != "textarea") isValid = !stringEmpty(child.value);
                          else isValid = !stringEmpty(child.innerHTML);
                          if (!isValid) break;
                        }
                    }
                }
            }
            isValid = isValid || isChecked;
        }
        else
        {
          if ((tagNm == "input") && (ctl.type.toLowerCase() == "checkbox")) isValid = ctl.checked;
          else if (tagNm == "select") isValid = (ctl.value != "-1");
          else if (tagNm != "textarea") isValid = !stringEmpty(ctl.value);
          else isValid = !stringEmpty(document.all ? ctl.innerHTML : ctl.value);
        }
        displayValidatorMessage(validator, isValid);
        validator.isValid = isValid;
        return isValid;
    }
    return true;
}

function fdv_addRequiredFieldValidator(id, controlId)
{
    return fdv_addValidator(id, controlId, "requiredField");
}

// Compare validators

function fdv_comp(ctl, validator)
{
    if (ctl)
    {
        var isValid = true;
        var ci = getClientId(ctl);
        var otherCtl = document.getElementById(ci + '_' + validator.compareTo);
        
        if (otherCtl)
        {
            isValid = (ctl.value == otherCtl.value);
            displayValidatorMessage(validator, isValid);
            validator.isValid = isValid;
            return isValid;
        }
    }
    return true;
}

function fdv_addCompareValidator(id, controlId, otherControlId)
{
    var validator = fdv_addValidator(id, controlId, "compare");

    validator.compareTo = otherControlId;
    return validator;
}

// Custom validators

function fdv_custom(ctl, validator)
{
    if (ctl)
    {
        var isValid = true;
        var val = (typeof(ctl.value)=="string"?ctl.value:ctl.id);
        
        isValid = eval(validator.funcName + "('" + val + "','" + getClientId(ctl.id) + "')");
        displayValidatorMessage(validator, isValid);
        validator.isValid = isValid;
        return isValid;
    }
    return true;
}

function fdv_addCustomValidator(id, controlId, funcName)
{
    var validator = fdv_addValidator(id, controlId, "custom");

    validator.funcName = funcName;
    return validator;
}

// Must be numeric validators

function fdv_mustBeNumeric(ctl, validator)
{
    if (ctl)
    {
        var isValid = true;
        var val = ctl.value;
        
        val = ctl.value.replace(':', '.');
        isValid = (stringEmpty(val) || (isNumber(val) && (parseFloat(val) >= 0)));
        displayValidatorMessage(validator, isValid);
        validator.isValid = isValid;
        return isValid;
    }
    return true;
}

function fdv_addMustBeNumericValidator(id, controlId)
{
    return fdv_addValidator(id, controlId, "mustBeNumeric");
}

//Files extensions

function file_extensionsCheck(evt)
{
	var src = (evt.tagName ? evt : getSrcElement(evt));

	if (src.value)
	{
	  var spans = null;
	  var parent = src.parentNode.parentNode
	  var prev = getPrevSibling(src.parentNode.parentNode);
	  var alwdext = src.getAttribute('alwdext');
	  var extensions = (alwdext ? alwdext.toLowerCase().split(',') : null);

	  if (prev && (prev.getAttribute('vtor') != '1')) prev = null;
	  if (prev) spans = prev.getElementsByTagName('span');
	  if (extensions && (extensions.length > 0))
	  {
		  var found = false;
		  var spl = src.value.split('.');
		  var ext = (spl.length > 1 ? spl[spl.length - 1] : null);

		  if (ext) ext = ext.toLowerCase();
		  for (var i=0;i<extensions.length;i++)
		  {
			  found = (extensions[i] == ext);
			  if (found) break;
		  }
		  if (!found)
		  {
			  if (!prev) alert(ext + ', File extension is not valid');
			  else
			  {

				  for (var i=0;i<spans.length;i++)
				  {
					  if (spans[i].getAttribute('extattr') != '1') continue;
					  prev.style.display = '';
					  spans[i].style.display = '';
					  break;
				  }
			  }
		  }
		  else
		  {
			  var otherDisplayed = false;

			  for (var i=0;i<spans.length;i++)
			  {
				  if (spans[i].getAttribute('extattr') == '1') spans[i].style.display = 'none';
				  else if (spans[i].style.display == '')
				  {
					  otherDisplayed = true;
					  break;
				  }
			  }
			  if (!otherDisplayed && prev) prev.style.display = 'none';
		  }    
		  return found;
	  }
	}
	return true;
}

function validateFileExtensions()
{
	var err;
	var isValid = true;
	var files = document.getElementsByTagName('input');
	for (var i=0;i<files.length;i++)
	{
		if (files[i].type.toLowerCase() != 'file') continue;
		err = file_extensionsCheck(files[i]);
		if (isValid) isValid = err;
	}
	return isValid;
}