//+------------------------------------------------------------------------------
//
// JS funkce pro kontrolu datovych typu
//
// Nazev: DataTypes.js
//
// Projekt: Reality Makers
//
// Obsah: Knihovna funkci pro projekt Reality Makers
//
// Vytvoreno: 27.5.2002
//
//-------------------------------------------------------------------------------

/////////////////////////////////////////////////////
//----------- OBECNE - JS pro FORM ------------------
/////////////////////////////////////////////////////


// This function will trim leading and/or trailing spaces from a string
// arg = the value you wish to have trimmed..
// func = "left" for Ltrim(), "right" for RTrim() or "both" for Trim()

//===================================
function trim(arg,func) {
//===================================

	var trimvalue = "";
	arglen = arg.length;
	if (arglen < 1) return trimvalue;

	if (func == "left" || func== "both") {
		i = 0;
		pos = -1;
		while (i < arglen) {
			if (arg.charCodeAt(i) != 32 && !isNaN(arg.charCodeAt(i))) {
				pos = i;
				break;
			}
			i++;
		}
	}

	if (func == "right" || func== "both") {
		var lastpos = -1;
		i = arglen;
		while (i >= 0) {
			if (arg.charCodeAt(i) != 32 && !isNaN(arg.charCodeAt(i))) {
				lastpos = i;
				break;
			}
			i--;
		}
	}

	if (func == "left") {
			trimvalue = arg.substring(pos,arglen-1);
		}

	if (func == "right") {
		trimvalue = arg.substring(0,lastpos+1);
	}

	if (func == "both") {
		trimvalue = arg.substring(pos,lastpos + 1);
	}

	return trimvalue;

}



/////////////////////////////////////////////////////
//----------- OBECNE - JS datum ---------------------
/////////////////////////////////////////////////////

function createDate(d,m,y) {
  var newDate = new Date(y, m - 1, d)
  return newDate
}
 
//-------------------------------------------------------------------------
// Nazev :        getFormattedDate
// Popis :        zformatuje datum na tvar dd.mm.yyyy
// Argumenty :    myDate - vstupni datum
// Vraci :        zformatovane datum
//-------------------------------------------------------------------------
function getFormattedDate(myDate) {
  return (myDate.getDate() + "." + (myDate.getMonth()+1) + "." + myDate.getFullYear())
}

//-------------------------------------------------------------------------
// Nazev :        getActualDate
// Popis :        vraci dnesni datum ve formatu dd.mm.yyyy
// Argumenty :    zadne
// Vraci :        nic
//-------------------------------------------------------------------------

function getActualDate() {
   var actDate = new Date()
   return getFormattedDate(actDate)
}

//-------------------------------------------------------------------------
// Nazev :        getActualYear
// Popis :        vraci aktualni rok (4 mistny)
// Argumenty :    zadne
// Vraci :        nic
//-------------------------------------------------------------------------

function getActualYear() {
   var actDate = new Date()
   return (actDate.getFullYear())
}

//-------------------------------------------------------------------------

function FormatFormDate(value)
{
  if(!isEmpty(value))
  {
    var arr = value.split(".");
    if (arr.length == 3)
    {
      var d = RemoveZero(arr[0]);
      var m = RemoveZero(arr[1]);
      var y = FullYear(arr[2]);
      
      return(d + '.' + m + '.' + y);
    }
    else
    {  
      return(value);
    }
  }
  else
  {
    return(value);
  }  
}


function FullYear(value)
{
  if(!isEmpty(value))
  {
    var YearTmp = parseInt(getActualYear()/100)
    if(value.length == 2)
    {
      return(YearTmp + value);
    }
    else
    {
      return(value);
    }  
  }
  else
  {
    return(value);
  }
}

//-------------------------------------------------------------------------

function isDate(val) {
  return (getFormattedDate(parseDate(val)) == FormatFormDate(val))
}

//-------------------------------------------------------------------------

function parseDate(val) {

  var input = val + ""; 
  
  if (!isEmpty(input)) {
  
    var arr = input.split(".")
    if (arr.length == 3) {
    
      var d = arr[0]
      var m = arr[1]
      var y = arr[2]
      
      if (isIntegerInRange(RemoveZero(d),0,31) && isIntegerInRange(RemoveZero(m),1,12) && isIntegerInRange(FullYear(y),1900,2100))
        return (createDate(RemoveZero(d),RemoveZero(m), FullYear(y)))
    }   
  }
return (createDate(1,0,1))
}



/////////////////////////////////////////////////////
//----------- OBECNE - JS cisla ---------------------
/////////////////////////////////////////////////////

function isEmpty(value)  {
  //return (value.length == 0)
  val = trim(value,"both")
  return (val.length == 0)
} 
  
function isNumber(value) {
  return !(isNaN(value) || isEmpty(value))
} 

function isInt(value) {
  return (parseInt(value) == value)
}

function isFloat(value) {
  return (parseFloat(value) == value)
}

function isIntegerInRange(value, min, max) {
  return (isInt(value) && (value >= min) && (value <= max))
}

function RemoveZero(value)
{
  if (value.length < 2)
  {
    return(value);
  }
  else
  {
    if(value.indexOf('0') == 0)
    {
      return(value.charAt(1));
    }
    else
    {
      return(value);
    }  
  }
}

function isFloatInRange(value, min, max) {
  return (isFloat(value) && (value >= min) && (value <= max))
}

function isNumberInRange(value, min, max, places) {
  if (places > 0)
    return ((isFloatInRange(value,min,max)) && (custRound(value,places)==value))
  else
    return (isIntInRange(value,min,max))
}

function custRound(x,places) {
	return (Math.round(x*Math.pow(10,places)))/Math.pow(10,places)
}

/////////////////////////////////////////////////////
//----------- SQL SERVER ----------------------------
/////////////////////////////////////////////////////


var SQL_BIGINT_MIN   = -9223372036854775808
var SQL_BIGINT_MAX   =  9223372036854775807
var SQL_INT_MIN      = -2147483648
var SQL_INT_MAX      =  2147483647
var SQL_SMALLINT_MIN = -32768
var SQL_SMALLINT_MAX =  32767
var SQL_TINYINT_MIN  =  0
var SQL_TINYINT_MAX  =  255
var SQL_MONEY_MIN    = -922337203685477.5808
var SQL_MONEY_MAX    =  922337203685477.5807

function isSqlSmallInt(value){
  return isIntegerInRange(value, SQL_SMALLINT_MIN, SQL_SMALLINT_MAX)
}

function isSqlTinyInt(value){
  return isIntegerInRange(value, SQL_TINYINT_MIN, SQL_TINYINT_MAX)
}

function isSqlInt(value){
  return isIntegerInRange(value, SQL_INT_MIN, SQL_INT_MAX)
}

function isSqlBigInt(value){
  return isIntegerInRange(value, SQL_BIGINT_MIN, SQL_BIGINT_MAX)
}

function isSqlMoney(value){
  return isFloatInRange(value, SQL_MONEY_MIN, SQL_MONEY_MAX)
}


/////////////////////////////////////////////////////
//----------- TOYOTA --------------------------------
/////////////////////////////////////////////////////

var TM_MONEY_MIN    =  0
var TM_MONEY_MAX    =  100000000000
var TM_MONEY_PLACES =  2

function isTmMoney(value){
  return isNumberInRange(value, TM_MONEY_MIN, TM_MONEY_MAX, TM_MONEY_PLACES)
}

function isStringInRange(value, minLen, maxLen){
  return ((value.length >= minLen) && (value.length <= maxLen))
}



function parseTmString(value, minLen, maxLen, name, lang){
  
  value = trim(value,"both")
  
  if (!isStringInRange(value, minLen, maxLen)) {
    
    //alert (name + " value='" + value + "', isEmpty = " + isEmpty(value) + ", povinne=" + (minLen > 0))
    
    if (isEmpty(value) && (minLen > 0)) 
    {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " must be filled");  
          break;
        default:
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");        
          break;
      }   
    }
      
    if (value.length < minLen) 
    {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " musí obsahovat nejméně " + minLen + " znaků");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " must be at least " + minLen + " chars");        
          break;
        default:
          return ("\nPolíčko " + "- " + name + " musí obsahovat nejméně " + minLen + " znaků");
          break;
      }   
    }
     
    if (value.length > maxLen) 
    {   
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " je příliš dlouhé (max. " + maxLen + " znaků");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " is too long (max " + maxLen + " chars)");
          break;
        default:
          return ("\nPolíčko " + "- " + name + " je příliš dlouhé (max. " + maxLen + " znaků");
          break;
      }   
    }  
  }
  return ("")
}

function parseTmStringNotReq(value, minLen, maxLen, name, lang)
{
  if (!isStringInRange(value, minLen, maxLen)) {
         
    if (value.length < minLen)
    {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " musí obsahovat nejméně " + minLen + " znaků");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " must be at least " + minLen + " chars");
          break;
        default:
          return ("\nPolíčko " + "- " + name + " musí obsahovat nejméně " + minLen + " znaků");
          break;
      }   
    }  
    
    if (value.length > maxLen)   
    {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " je příliš dlouhé (max. " + maxLen + " znaků");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " is too long (max " + maxLen + " chars)");
          break;
        default:
          return ("\nPolíčko " + "- " + name + " je příliš dlouhé (max. " + maxLen + " znaků");
          break;
      }   
    }  
  }
  return ("")
}

function parseNumber(value, name, lang)
{
  if (!isEmpty(value))
  {
  if (!isTmMoney(value)) 
      if (isNumber(value)) {
        if (value < TM_MONEY_MIN)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo větší než " + TM_MONEY_MIN );
              break;
            case 'EN':
              return ("\n" + "- " + name + " must be number greater than " + TM_MONEY_MIN );
              break;
            default:
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo větší než " + TM_MONEY_MIN );
              break;
          }   
        }  
        if (value > TM_MONEY_MAX)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo menší než " + TM_MONEY_MAX );
              break;
            case 'EN':
              return ("\n" + "- " + name + " must be number smaller than " + TM_MONEY_MAX )
              break;
            default:
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo menší než " + TM_MONEY_MAX );
              break;
          }   
        
        }  
        if (custRound(value,TM_MONEY_PLACES)!=value)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nPolíčko " + "- " + name + " musí mít maximálně " + TM_MONEY_PLACES + " desetinných míst");
              break;
            case 'EN':
              return ("\n" + "- " + name + " must have max " + TM_MONEY_PLACES + " decimal places")              
              break;
            default:
              return ("\nPolíčko " + "- " + name + " musí mít maximálně " + TM_MONEY_PLACES + " desetinných míst");
              break;
          }   
        }  
      }    
      else
      {
        switch(lang)
        {
          case 'CZ':
            return ("\nV políčku " + "- " + name + " musí být číslo")
            break;
          case 'EN':
            return ("\n" + "- " + name + " must be number")
            break;
          default:
            return ("\nV políčku " + "- " + name + " musí být číslo")
            break;
        }   
      }  
  }
  return ("")    
}


function parseTmMoney(value, name, lang){
  if (isEmpty(value))
  {
    if (isEmpty(value)) 
    {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " must be filled");
          break;
        default:
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");
          break;
      }   
    }
  }
  else {
    if (!isTmMoney(value)) 
      if (isNumber(value)) {
        if (value < TM_MONEY_MIN)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo větší než " + TM_MONEY_MIN );
              break;
            case 'EN':
              return ("\n" + "- " + name + " must be number greater than " + TM_MONEY_MIN );
              break;
            default:
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo větší než " + TM_MONEY_MIN );
              break;
          }   
        }  
        if (value > TM_MONEY_MAX)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo menší než " + TM_MONEY_MAX );
              break;
            case 'EN':
              return ("\n" + "- " + name + " must be number smaller than " + TM_MONEY_MAX )
              break;
            default:
              return ("\nHodnota v políčku " + "- " + name + " musí být číslo menší než " + TM_MONEY_MAX );
              break;
          }   
        
        }  
        if (custRound(value,TM_MONEY_PLACES)!=value)
        {
          switch(lang)
          {
            case 'CZ':
              return ("\nPolíčko " + "- " + name + " musí mít maximálně " + TM_MONEY_PLACES + " desetinných míst");
              break;
            case 'EN':
              return ("\n" + "- " + name + " must have max " + TM_MONEY_PLACES + " decimal places")              
              break;
            default:
              return ("\nPolíčko " + "- " + name + " musí mít maximálně " + TM_MONEY_PLACES + " desetinných míst");
              break;
          }   
        }  
      }    
      else
      {
        switch(lang)
        {
          case 'CZ':
            return ("\nV políčku " + "- " + name + " musí být číslo")
            break;
          case 'EN':
            return ("\n" + "- " + name + " must be number")
            break;
          default:
            return ("\nV políčku " + "- " + name + " musí být číslo")
            break;
        }   
      }  
  }
  return ("")     
}


function parseTmDate (value, name, due, minDate, maxDate, lang) {
  if ((due) && isEmpty(value))
  {
      switch(lang)
      {
        case 'CZ':
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");        
          break;
        case 'EN':
          return ("\n" + "- " + name + " must be filled");  
          break;
        default:
          return ("\nPolíčko " + "- " + name + " musí být vyplněno");        
          break;
      }   
  }  
  
  if (!isEmpty(value))
  {
    if (isDate(value)) 
    {
      if (!isDateBetween(value, minDate, maxDate))
      {
        switch(lang)
        {
          case 'CZ':
            return ("\nPolíčko " + "- " + name + " musí být datum mezi " + minDate + " a " + maxDate)
            break;
          case 'EN':
            return ("\n" + "- " + name + " must be date between " + minDate + " and " + maxDate)
            break;
          default:
            return ("\nPolíčko " + "- " + name + " musí být datum mezi " + minDate + " a " + maxDate)        
            break;
        }   
      }  
    }  
    else
    {
        switch(lang)
        {
          case 'CZ':
            return ("\nPolíčko " + "- " + name + " musí být datum ve formátu '4.3.2002' nebo ve formátu '04.03.2002', rok mezi 1900 a 2100")
            break;
          case 'EN':
            return ("\n" + "- " + name + " must be date in format '4.3.2002' or in format '04.03.2002', year between 1900 and 2100")
            break;
          default:
            return ("\nPolíčko " + "- " + name + " musí být datum ve formátu '4.3.2002' nebo ve formátu '04.03.2002', rok mezi 1900 a 2100")
            break;    
        }
    }  
  }
  
  return ("")   
}


function isDateBetween(value, minDate, maxDate, lang)
{
  if (isDate(value) && isDate(minDate) && isDate(maxDate)) {
   var valDate = parseDate(value)
   return ((valDate >= parseDate(minDate)) && (valDate <= parseDate(maxDate)))
  } 
  else
  {
    switch(lang)
    {
      case 'CZ':
        return ("Jeden z parametrů není datum ve správném formátu.");        
        break;
      case 'EN':
        alert ("One or more input param is not valid date.")        
        break;
      default:
        return ("Jeden z parametrů není datum ve správném formátu.");        
        break;
    }   
  }
}


function replaceChars(entry, replThis, replWith)
{
  out = replThis
  add = replWith
  temp = "" + entry

  while (temp.indexOf(out)>-1) 
  {
    pos= temp.indexOf(out);
    temp = "" + (temp.substring(0, pos) + add + 
    temp.substring((pos + out.length), temp.length));
  }
  return (temp)
}


function commaToPoint (value)
{
  if (!isEmpty(value))
  {
    return (replaceChars(value,",","."))
  }  
  else
  {
    return ""  
  }  
}

function removeSpaces () 
{
}