hypersonicplus 0.0.0

data/lib/hmisc/hinputvalidator.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+# Go to http://rubular.com to try the regex strings
+
+class HInputValidator
+  
+  def self.isValid?(input)  # General Validation
+    
+    return self.isLengthValid?(input)
+
+  end
+ 
+  def self.isLengthValid?(input)
+
+    regex = /\A.{0,40}\z/
+    return !(input !~ regex)
+
+  end
+ 
+  def self.isMandatory?(input)
+    
+    regex = /\A.{1,500}\z/
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isPassword?(input)
+    
+    regex = /^[\w.@!$\-]{5,}$/  # at least 5 character, are allow the follows special chars: . @ ! $ -
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isReal?(input)
+    
+    regex = /^-?[0-9]\d*(\.\d+)?$/
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isInteger?(input)
+    
+    regex = /\A-?[0-9]+\z/
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isNatural?(input)
+    
+    regex = /\A[0-9]+\z/
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isEmail?(input)
+
+    regex = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+    return !(input !~ regex) && self.isValid?(input)
+
+  end
+
+  def self.isUnique?(fieldValue, fieldName, modelName)
+
+    result = HSqlTable.new().loadFromQuery("select count(*) from #{modelName} where #{fieldName} = '#{fieldValue}'")[0][0]
+    return (result == "1") && self.isValid?(fieldValue)
+
+  end
+
+  # isValid("hb@gmail.com", "email,unique", "email", "users") 
+  def self.isValid(fieldValue, fieldType, fieldName, modelName)
+
+    result = true
+    types = fieldType.split(",")
+    types.each do |type|
+      type = type.strip()
+      result &&= self.isLengthValid?(fieldValue) if (type == "length")
+      result &&= self.isMandatory?(fieldValue) if (type == "mandatory")
+      result &&= self.isPassword?(fieldValue) if (type == "password")
+      result &&= self.isReal?(fieldValue) if (type == "real")
+      result &&= self.isInteger?(fieldValue) if (type == "integer")
+      result &&= self.isNatural?(fieldValue) if (type == "natural")
+      result &&= self.isEmail?(fieldValue) if (type == "email")
+      result &&= self.isUnique?(fieldValue, fieldName, modelName) if (type == "unique")
+    end
+
+    return (result) ? "true": "false"
+
+  end
+
+  def self.valid?(fieldValue: nil, fieldType: nil, fieldName: nil, modelName: nil)
+    return self.isValid(fieldValue, fieldType, fieldName, modelName)
+  end
+
+
+end

data/lib/hmisc/hio.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+
+require 'net/smtp'
+require 'mail'
+
+def puta(array, margin: 0) 
+  array.each do |value|
+    puts " " * margin + "#{value}".green if value.class != Hash and value.class != Array
+    puth(value, margin: margin + 3) if value.class == Hash
+  end
+end
+
+def puth(hash, margin: 0) 
+  hash.each do |key, value|
+    puts " " * margin + "#{key}:".hight_cyan 
+    puts " " * (margin + 3) + "#{value}".hight_cyan if value.class != Hash and value.class != Array
+    puta(value, margin: margin + 3) if value.class == Array
+  end
+end
+
+class HIO
+
+ @@indentSpace = 0
+
+  def self.htmlEcholn(str)
+    return "" if (str == "")
+    #return str.to_s
+    return str.to_s + "\n"
+  end
+
+  def self.htmlEcholnOpenBlock(str)
+
+    result = self.htmlEcholn(str)
+    @@indentSpace += 1
+    return result
+  
+  end
+
+  def self.htmlEcholnCloseBlock(str)
+
+    @@indentSpace -= 1
+    return self.htmlEcholn(str);
+
+  end
+
+  def self.quote(str) 
+    return "'#{str}'";
+  end
+    
+  def self.isQuoted(str) 
+
+    return (str[0] == "'" && str[-1] == "'")
+
+  end 
+
+  def self.unQuote(str) 
+
+    return isQuoted(str) ? str[1..-2] : str
+
+  end
+
+  def self.gmailOptions(username, password) 
+
+    return options = { 
+      :address              => "smtp.gmail.com",
+      :port                 => 587,
+      :user_name            => username,
+      :password             => password,
+      :authentication       => 'plain',
+      :enable_starttls_auto => true  
+    }
+
+  end
+
+
+  def self.gmxOptions(username, password) 
+
+    return options = { 
+      :address              => "mail.gmx.com",
+      :port                 => 587,
+      :user_name            => username,
+      :password             => password,
+      :authentication       => 'plain',
+      :enable_starttls_auto => true
+    }
+
+  end
+
+  def self.options(emailFrom, emailPassword)
+    
+    provider = emailFrom[emailFrom.index('@') + 1, emailFrom.size - 1]
+    return self.gmxOptions(emailFrom, emailPassword) if(provider == "gmx.com")
+    return self.gmailOptions(emailFrom, emailPassword) if(provider == "gmail.com")
+
+  end
+
+
+  def self.sendEmail(emailFrom, emailTo, emailSubject, emailBody, emailPassword = "quickorder", emailFromName = "") 
+
+    Mail.defaults do
+      delivery_method :smtp, self.options(emailFrom, emailPassword)
+    end
+
+    Mail.deliver do
+      to emailTo
+      from emailFrom 
+      subject emailSubject
+      body emailBody
+    end
+
+
+
+=begin
+message = <<MESSAGE_END
+From: Private Person <herbert.bonaffini@gmx.com>
+To: A Test User <herbert.bonaffini@gmail.com>
+Subject: SMTP e-mail test
+
+This is a test e-mail message.
+MESSAGE_END
+
+Net::SMTP.start('smtp.gmx.com', 465, 'localhost', 'herbert.bonaffini@gmx.com', 'quickorder', :plain) do |smtp|
+  smtp.send_message message, 'herbert.bonaffini@gmx.com', 
+                             'herbert.bonaffini@gmail.com'
+end
+
+
+    provider = substr($emailFrom, strpos($emailFrom, '@') + 1);
+
+    if(provider == "gmx.com")
+      phpMailer = HIO::gmxPHPmailer();
+    else
+      phpMailer = HIO::gmailPHPmailer();
+
+      phpMailer->Username = emailFrom;
+      phpMailer->Password = password;
+=end
+
+  end
+
+end
+

data/lib/hmisc/hjson.rb

@@ -0,0 +1,16 @@
+ESCAPED_CHARS = {
+  '>'      => '\u003e',
+  '<'      => '\u003c',
+  '&'      => '\u0026',
+  "\u2028" => '\u2028',
+  "\u2029" => '\u2029',
+}
+
+ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
+
+class String 
+  def to_json
+    super.gsub ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
+  end
+end
+

data/lib/hsqlmanager/hpgsqldatabasemanager.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require "hsqlmanager/hsqldatabasemanager"
+
+class HPgSqlDatabaseManager < HSqlDatabaseManager
+
+  def connect()
+
+    timezone = hc.value("timezone")
+
+    return @connection if(@connection != nil)
+
+    connectionPtr = HSharedData.instance().value("pg-#{@dbname}")
+    return connectionPtr.connection if (connectionPtr != nil)
+
+    connection = PGconn.new(@host, @port, "", "", @dbname, @user, @password)
+    HSharedData.instance().setValue(self, "pg-#{@dbname}")
+    puts "Server version: #{connection.query("SHOW server_version").to_s}"
+    connection.query("SET TIME ZONE '#{timezone}'");
+    return connection
+
+  end
+
+  def close()
+
+    HSharedData.instance().setValue(nil, "pg-#{@dbname}")
+    
+  end
+
+  def self.setPgSqlConnection()
+
+    host   = hc.value("host")
+    port   = hc.value("port")
+    dbname = hc.value("dbname")
+    user   = hc.value("user")
+    password = hc.value("password")
+
+    pgSqlDatabaseManager = HPgSqlDatabaseManager.new(host, port, dbname, user, password) 
+    pgSqlDatabaseManager.openConnection()
+    return pgSqlDatabaseManager
+
+  end
+
+
+  def self.defaultPgSqlDatabaseManager()
+
+    pgDbName = hc.value("pg_dbname")
+    pgSqlDatabaseManager = HSharedData.instance().value("pg-#{pgDbName}")
+    return (pgSqlDatabaseManager == nil) ? self.setPgSqlConnection() : pgSqlDatabaseManager
+
+  end
+
+
+  def self.test1()
+
+    pgSqlDatabaseManager = HPgSqlDatabaseManager.new("127.0.0.1", "5432", "quickorder", "quickorder", "quickorder") 
+    pgSqlDatabaseManager.openConnection()
+    # la seguente query genera 3 colonne invece di 4
+    # si tratta di un bug
+    result = pgSqlDatabaseManager.run("select id, name, price, name from cookbook")
+    # come toppa si puo' usare la seguente query
+    #result = pgSqlDatabaseManager.run("select id, name, price, name as ciao from cookbook")
+    pgSqlDatabaseManager.show()
+
+  end
+
+end
+
+def hpgsql()
+
+  return HPgSqlDatabaseManager.defaultPgSqlDatabaseManager()
+
+end
+
+#hpgsql.test1
+

data/lib/hsqlmanager/hsqldatabasemanager.rb

@@ -0,0 +1,349 @@
+#!/usr/bin/env ruby
+      
+# databaseManager.select("id, name").from("cookbook").where("id > 10").orderBy("id").limit(5).offset(5).run().show()
+
+
+class HSqlDatabaseManager
+
+  attr_reader :resultTable, :connection
+
+  def initialize(host, port, dbname, user, password)
+
+    @host = host
+    @port = port
+    @dbname = dbname
+    @user = user
+    @password = password
+
+    @connection = nil
+
+    @select = nil
+    @from = nil
+    @where = nil
+    @orderBy = nil
+    @limit = nil
+    @offset = nil
+
+    @resultTable = nil
+
+  end
+
+  # posso passare anche un array di campi
+  def select(select)
+    select = select.join(',') if(select.class == Array)
+    @select = select
+    return self
+  end
+  def from(from)
+    @from = from
+    return self
+  end
+  def where(where)
+    @where = where
+    return self
+  end
+  def orderBy(orderBy)
+    @orderBy = orderBy
+    return self
+  end
+  def limit(limit)
+    @limit = limit
+    return self
+  end
+  def offset(offset)
+    @offset = offset
+    return self
+  end
+  
+  def queryStr()
+ 
+    where = "where #{@where}" if(@where)
+    orderBy  = "order by #{@orderBy}" if(@orderBy)
+    limit = "limit #{@limit}" if(@limit)
+    offset = "offset #{@offset}" if(@offset)
+    return "select #{@select} from #{@from} #{where} #{orderBy} #{limit} #{offset}"
+
+  end
+
+
+  def openConnection()
+
+    @connection = self.connect() if(@connection == nil)
+
+  end
+
+
+  def closeConnection()
+
+    @connection.close() if(@connection != nil)
+    @connection = nil
+    self.close()
+  
+  end
+
+
+  def fieldNameList()
+
+    fieldList = HList.new()
+
+    for i in (0..@resultTable.nfields() - 1)
+      fieldList.insertTail(HRecord.new(@resultTable.fname(i)))
+    end
+
+    return fieldList
+
+  end
+
+  def run(queryStr = self.queryStr) 
+
+    @resultTable = @connection.query(queryStr)
+    return self
+
+  end
+
+#  def setQuery(queryStr)
+#    return self.run(queryStr)
+#  end
+
+  def runWithPaging(pageSize = "all", page = 0, queryStr = self.queryStr) 
+    
+    limit = "limit #{pageSize}"
+    offset = "offset #{page} * #{pageSize}"
+    if(pageSize == "all")
+      limit = offset = ""
+    end
+
+    queryStr += " #{limit} #{offset}"
+   
+    return self.run(queryStr)
+
+  end
+
+  def dataByFieldName(row, fieldName)
+  
+    return nil if(@resultTable.count() == 0)  
+    return @resultTable[row][fieldName]
+
+  end
+
+  def dataByFieldIndex(row, fieldIndex)
+
+    return self.dataByFieldName(row, @resultTable.keys[fieldIndex])
+
+  end
+  
+  # Se si vuole efficienza conviene non usare la seguente funzione
+  # ma le precedenti
+  def toSqlTable()
+
+    sqlTable = HSqlTable.new()
+
+    fieldNameList = self.fieldNameList()
+
+    fieldNameList.eachWithIndex do |fieldName, i|
+      sqlTable.setFieldName(i, fieldName.value(), "true");
+    end
+
+    @resultTable.each_with_index do |row, i|  
+      j = 0
+      row.each do |key, value|
+        sqlTable.setDataByFieldIndex(i, j, HRecord.new(value))
+        j += 1
+      end
+    end
+
+    return sqlTable
+
+  end
+
+  def rowCount()
+
+    return @resultTable.count()
+
+  end
+
+  def columnCount()
+
+    return 0 if(self.rowCount() == 0)
+    return @resultTable[0].count()
+
+  end
+
+  
+  def quoteValue(value)
+      
+      return nil unless(value)
+      return (value[0] != '#') ? "'#{value}'" : value[1, value.size - 1]
+
+  end
+
+
+  # quota tutti i valori tranne quelli che iniziano con #
+  # quindi se nella mia query devo richiamare una funzione basta farla precedere dal cancelletto
+  def quote(args)
+    
+    return nil unless(args)
+
+    result = Hash.new()
+
+    args.each do |key, value|
+      result[key] = self.quoteValue(args[key])
+    end
+    return result
+
+  end
+
+
+  def insertValues(args) 
+
+    return "(id) values(default)" unless(args)
+
+    args = self.quote(args)
+
+    keys = args.keys
+
+    result = "("
+    i = -1
+    for i in (0..args.count - 2) do
+      result += "#{keys[i]}, "
+    end
+    result += "#{keys[i + 1]}) values("
+    i = -1
+    for i in (0..args.count - 2) do
+      result += "#{args[keys[i]]}, "
+    end
+    result += "#{args[keys[i + 1]]})"
+    return result
+
+  end
+
+  def updateValues(args) 
+
+    return "" unless(args)
+    
+    args = self.quote(args)
+
+    keys = args.keys
+
+    result = ""
+    i = -1
+    for i in (0..args.count - 2) do
+      result += "#{keys[i]} = #{args[keys[i]]}, "
+    end
+    result += "#{keys[i + 1]} = #{args[keys[i + 1]]}"
+    
+    return result
+
+  end
+
+  def insertOrUpdateIfExist(tableName, where, values = nil)
+
+    resultTable = self.run("select id from #{tableName} where #{where} ").resultTable
+    if(resultTable.count == 0)
+      insertQuery = "insert into #{tableName} #{self.insertValues(values)} returning id"
+      p "================= insertOrUpdateIfExist ================== ", insertQuery
+      newId = self.run(insertQuery).resultTable[0]["id"]
+      return newId
+    else
+      p values
+      updateQuery = "update #{tableName} set #{self.updateValues(values)} where #{where}"
+      p updateQuery
+      self.run(updateQuery) if(values)
+      return resultTable[0]["id"]
+    end
+
+  end
+  
+  def insertOrUpdateIfExistCached(tableName, dialogViewLevel, id, values)
+
+    value = {}    
+    value[:view_level] = dialogViewLevel
+    value[:table_name] = tableName
+    value[:field_id] = id
+    value[:field_value] = values
+    value[:state] = "none"
+
+    return self.insertOrUpdateIfExist("cache_table", "table_name = '#{tableName}' and field_id = #{id}", value)
+
+  end
+
+  def unloadCache(tableName, dialogViewLevel, id)
+
+    p "unloadCache"    
+    resultTable = self.run("select field_id, field_value from cache_table where table_name = '#{tableName}'").resultTable
+    resultTable.each do |row|
+      self.insertOrUpdateIfExist(tableName, "id = #{row['field_id']}", eval(row['field_value']))
+    end
+    self.run("delete from cache_table where table_name = '#{tableName}'").resultTable
+
+  end
+
+  def deleteCacheBranch(tableName, dialogViewLevel)
+    
+    self.run("delete from cache_table where table_name = '#{tableName}' and view_level >= #{dialogViewLevel}").resultTable
+
+  end
+
+  def setParentChildTableValues(parentTableName, childTableName, where, parentValues, childValues)
+
+    parentTableId = self.insertOrUpdateIfExist("#{parentTableName}_table", where, parentValues)
+
+    i = 0
+    record = Hash.new()
+    childValues.each do |key, value|
+      childRecord = {"#{parentTableName}_id" => parentTableId,
+                :field_name => key,
+                :field_value => value,
+                :ordering => i}
+      recordWhere = "#{parentTableName}_id = #{parentTableId} and field_name = '#{key}'"
+      self.insertOrUpdateIfExist("#{childTableName}_table", recordWhere, childRecord)
+      i += 1
+
+    end
+  end
+
+  def extractFromHash(value, key = nil)
+
+    return nil unless(value)
+    value = eval(value) if(value[0] == '{' && value[-1] == '}') # E' un hash table
+    return value[key] if(value && key)
+    return value
+
+  end
+
+  def parentChildValueOf(parentTableName, childTableName, parentTableId, fieldName, key = nil)
+
+    return nil if(parentTableId == -1)
+    
+    selectQuery = "select field_value from #{childTableName}_table where field_name = '#{fieldName}' and #{parentTableName}_id = #{parentTableId}"
+    value = self.run(selectQuery).dataByFieldName(0, "field_value")
+    return extractFromHash(value, key)
+
+  end
+  
+  def parentChildValueOfByUsername(parentTableName, childTableName, username, fieldName, key = nil)
+
+    selectQuery = "select id from #{parentTableName}_table where username = '#{username}'"
+    parentTableId = self.run(selectQuery).dataByFieldName(0, "id")
+    return self.parentChildValueOf(parentTableName, childTableName, parentTableId, fieldName, key)   
+
+  end
+
+  def show()
+  
+    self.fieldNameList().show()
+    puts
+    @resultTable.each do |row|  
+      row.each do |key, value|
+        print "%-15s" % row[key]
+      end
+      puts
+    end
+
+  end
+
+end
+
+
+
+