hypersonic-plus 0.0.0

data/lib/hsqlmanager/hsqltable.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require "hdatastructures/hspreadfieldtable"
+
+class HSqlTable < HSpreadFieldTable 
+
+    attr_accessor :tableName, :sortField, :filter 
+
+    def initialize(tableName = nil, filter = "true", sortField = "id")
+        super()
+        @tableName = tableName
+        @filter = filter
+        @sortField = sortField
+    end
+
+
+end

data/lib/husermanager/husermanager.rb

@@ -0,0 +1,122 @@
+class HUserManager 
+
+  include Singleton
+  include BCrypt
+
+  def initialize(databaseManager = nil)
+    
+    @databaseManager = (databaseManager == nil) ? hpgsql() : databaseManager
+
+  end
+
+  def sanitize(str)
+     
+    return str.gsub("'", "\'") 
+  
+  end
+
+  def userNameToUserId(userName)
+
+    query = "select id from user_table where username = '#{userName}'"
+    return @databaseManager.run(query).dataByFieldName(0, "id")
+
+  end
+
+  def getUserValueById(userId, fieldName)  
+
+    return nil if(fieldName == "")
+    fieldName = self.sanitize(fieldName)
+
+    query = "select profile_value from user_profile_table where profile_key = '#{fieldName}' and user_id = '#{userId}'";
+    return @databaseManager.run(query).dataByFieldName(0, "profile_value")
+  
+  end
+
+
+  def getUserValueByUserName(userName, fieldName) 
+
+    return nil if(userName == "" || fieldName == "")
+
+    fieldName = self.sanitize(fieldName)
+    userId = userNameToUserId(userName)
+
+    return (userId == nil) ? nil : getUserValueById(userId, fieldName)
+
+  end
+
+
+  def addProfileIfNotExist(userId, fieldName, fieldValue, ordering) 
+
+    query = "select id from user_profile_table where profile_key = '#{fieldName}' and id = #{userId}"
+    resultTable = @databaseManager.run(query).resultTable
+    self.newUserProfile(userId, fieldName, fieldValue, ordering) if(resultTable.count == 0)
+
+  end
+
+  def newUserProfile(userId, profileKey, profileValue, ordering) 
+   
+    userProfile = Hash.new()
+    userProfile["user_id"] = userId
+    userProfile["profile_key"] = profileKey
+    userProfile["profile_value"] = profileValue
+    userProfile["ordering"] = ordering
+    userProfileQuery = "insert into user_profile_table #{@databaseManager.insertValues(userProfile)}"
+    @databaseManager.run(userProfileQuery)
+
+  end
+ 
+  def newUser(user) 
+   
+    user[:password] = Password.create(HIO.unQuote(user[:password]))
+    user[:activation] = Digest::SHA1.hexdigest([Time.now, rand].join)
+    userQuery = "insert into user_table #{@databaseManager.insertValues(user)} returning id" 
+    return @databaseManager.run(userQuery).dataByFieldName(0, "id")
+
+  end
+
+  # return nil if user not found
+  # return -1 if mismatch password 
+  # return id if the username and password are ok
+
+  def autenticate(username, password)
+
+    query = "select id, password from user_table where username = '#{username}'"
+    resultTable = @databaseManager.run(query).resultTable
+    return nil if(resultTable.count == 0)
+    storePassword = resultTable[0]["password"]
+    return Password.new(storePassword).is_password?(password) ? resultTable[0]["id"] : -1
+
+  end
+
+  def deleteUser(username) 
+
+    query = "delete from user_table where username = '#{username}'"
+    @databaseManager.run(query)
+
+  end
+
+
+  def activationUrl(username)
+    
+    query = "select activation from user_table where username = '#{username}'"
+    return @databaseManager.run(query).dataByFieldName(0, "activation")
+
+  end
+
+
+  def self.test1()
+
+    userProfile = {:name => "Herbert", :familienname => "Bonaffini", :adresse => "Wien", :arbeit => "Developer"}
+    p hpgsql().insertValues(userProfile)
+    p hpgsql().updateValues(userProfile)
+
+    HUserManager.instance().addProfileIfNotExist(1, "familienname", "Bonaffini", 1) 
+    user = {:id => 'default', :username => "herbert.bonaffini9@gmail.com", :password => "ciao", :enabled => 1, :user_type_id => 1}
+    #p "id: #{HUserManager.instance().newUser(user)}"
+    p "autenticate: #{HUserManager.instance().autenticate('herbert.bonaffini9@gmail.com', "ciao")}"
+    p HUserManager.instance().activationUrl("herbert.bonaffini9@gmail.com")
+    return HUserManager.instance().getUserValueByUserName('herbert.bonaffini@gmail.com', 'address') 
+
+  end
+
+end

data/lib/hwidgets/haccordionmenu.rb

@@ -0,0 +1,117 @@
+class HAccordionMenu < HDivTag
+  
+  attr_reader :mainView
+
+  def initialize(items: [], id: nil, mainView: nil)
+    super(class: "haccordion-menu")
+    self.set(id: id) if id
+    #self.appendChild(HWidget.new("style", "##{id}:target { display: block; }", scoped: nil));
+    @items = items
+    @mainView = mainView
+  end
+
+  def addItem(value)
+    @items << value
+    return self
+  end
+
+  def a(innerHTML = '', icon: nil, **args)
+
+    a = HWidget.new("a", "", args)
+    a << HWidget.new('span', class: icon) if icon
+    a << HWidget.new('span', innerHTML)
+    return a
+
+  end
+
+  def onClick(moduleName: nil, modelName: nil)
+    hl << "HAccordionMenu.onClick (#{moduleName} - #{modelName})".red
+    return @mainView.html(moduleName: moduleName, modelName: modelName)
+  end
+
+
+  def appendChildren(parent, items)
+
+    items.each do |value|
+      if(value[:type] == 'link')
+        ref =  eval(value[:ref]) if value[:ref]
+        parent << link = (self.a(value[:name], icon: value[:icon]))
+        link.connect(:onclick, self, "onClick", id: @mainView.oid, args: ref)
+      elsif(value[:type].include? 'section' )
+        parent.appendChild( HDivTag.new(value[:name], class: "#{value[:type]}-name") )
+        sectionContentDiv = HDivTag.new(class: "#{value[:type]}-content")
+        parent.appendChild(sectionContentDiv)
+        self.appendChildren(sectionContentDiv, value[:content])
+      end
+    end
+
+  end
+
+
+  def html()
+    self.appendChildren(self, @items)
+    return super
+  end
+
+  def self.test1()
+
+    subSection = [
+      {type: 'section', name: 'Section-A', content:[
+        {type: 'link', name: 'Section-a1', href:'#'},
+        {type: 'link', name: 'Section-a2', href:'#'},
+        {type: 'link', name: 'Section-a3', href:'#'}
+      ]
+      },
+
+      {type: 'section', name: 'Section-B', content:[
+        {type: 'link', name: 'Section-b1', href:'#'},
+        {type: 'link', name: 'Section-b2', href:'#'},
+        {type: 'link', name: 'Section-b3', href:'#'}
+      ]
+      },
+    ]
+
+    openSection = [{type: 'link', name: 'O-Section1', href:'#', icon: 'glyphicon glyphicon-user'},
+                   {type: 'link', name: 'O-Section2', href:'#'},
+                   {type: 'link', name: 'O-Section3', href:'#'}
+    ]
+
+    items = [
+      {type: 'section', name: 'Section-A', content:[
+        {type: 'link', name: 'Section-a1', href:'#'},
+        {type: 'link', name: 'Section-a2', href:'#'},
+        {type: 'link', name: 'Section-a3', href:'#'}
+      ]
+      },
+
+      {type: 'section', name: 'Section-B', content: subSection},
+      {type: 'open-section', name: 'Open Section', content: openSection},
+    ]
+    return HAccordionMenu.new(items).html()
+
+  end
+
+  def self.appendChild1(parent, root = [])
+    parent.children.each do |item|
+      next if item.name == "text"
+      menuItem = item.to_h.symbolize_keys
+      if item.name == "menusection"
+        menuItem[:type] = "section" unless menuItem[:type]
+        menuItem[:content] = self.appendChild1(item) 
+      elsif item.name == "menuitem"
+        menuItem[:type] = "link"
+      end
+      root << menuItem
+    end
+    return root 
+
+  end
+
+  def self.loadMenuByModuleName(moduleName: nil, mainView: nil)
+    menuView = hv().viewByFileName(moduleName, "app/modules/#{moduleName}/menu_view.xml")
+    items = self.appendChild1(menuView.hypersonic)
+    return HAccordionMenu.new(items: items, id: moduleName, mainView: mainView).html()
+  end
+
+
+end

data/lib/hwidgets/hcheckboxtag.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require "hwidgets/hgrouptag"
+
+class HCheckBoxTag < HGroupTag
+
+    attr_accessor :checked
+
+    def initialize(name = nil, modelName = nil, placeholder = nil)
+      super(name, modelName, placeholder)
+      @checkBox = nil
+    end
+
+    def html()
+      for i in (0..@items.count - 1) do
+        item = @items[i]
+        value = @values[i]
+        id = "#{@modelName}_#{@name}_#{value.downcase()}"
+        name = "#{@modelName}[#{@name}][#{value}]"
+        hiddenCheckBox = HInputTag.new(@name, @modelName, nil, nil, type = "hidden").set(name: name, value: "0")
+        checkBox = HInputTag.new(@name, @modelName, value, nil, type = "checkbox") if (@checkBox == nil)
+        checkBox.placeholder = item
+        checkBox.set(checked: "") if (@selectedItem[value.to_s] == "1")
+        checkBox.set(name: name, value: "1", id: id)
+        checkBox.setReverse()
+        self << checkBox << hiddenCheckBox
+      end
+
+      return super()
+    
+    end
+
+end

data/lib/hwidgets/hdbactionbuttons.rb

@@ -0,0 +1,26 @@
+class HDBActionButtons < HDivTag
+
+  def initialize(sourceView: nil, buttons: [], **args)
+
+    @sourceView = sourceView
+    @buttons = buttons
+
+    return super(class: 'hdbactionbuttons', **args)
+  end
+
+
+  def html
+   
+    @buttons.each do |button|
+      action = button.delete(:action)
+      button = HWidget.new("button", button.delete(:name), class: "actionbutton", **button) 
+      button.connect(:onclick, @sourceView, "rpcAction", args: {action: action}, 
+                   id: @sourceView.oid, mode: 'none',
+                   attributes: ":hdbTableView.ids(obj) => ids")
+      self << button
+    end
+    
+    return super
+  end 
+
+end

data/lib/hwidgets/hdbcombobox.rb

@@ -0,0 +1,71 @@
+
+require "hwidgets/hdivtag"
+require "hwidgets/hgrouptag"
+require "hwidgets/hinputtag"
+
+class HDBComboBox < HDivTag
+
+    attr_accessor :selectTag, :newButton, :editButton
+
+    # fieldName: products_id
+    # showField: name
+
+    def initialize(moduleName, odb, fieldName, showedFieldName, label, selectedValue, oid, dialogLevel)
+      @odb = odb
+      @fieldName = fieldName
+      @showedFieldName = showedFieldName
+      @label = label
+      @selectedValue = selectedValue
+      @oid = oid
+      @dialogLevel = dialogLevel
+
+      @sourceModelName = odb.source.modelName
+      @moduleName = moduleName
+      @modelName = odb.modelName
+      super(id: oid)
+      
+      @selectTag = HSelectTag.new("id", "#{@sourceModelName}[#{fieldName}]", label)
+      @selectTag.setCarriageReturn()
+      @selectTag.set(id: "#{@modelName}-combobox", overwrite: true)
+
+      self << @selectTag
+      self << @newButton = HInputTag.init(name: "new", type: "button")
+      @newButton.connect(:onclick, self, "newRecord", getElem: "body", mode: "add", id: @oid);
+      self << @editButton = HInputTag.init(name: "edit", type: "button")    
+      @editButton.connect(:onclick, self, "edit", attributeById: "#{@modelName}-combobox", attributes: ":obj.value", getElem: "body", mode: "add", id: @oid);
+
+    end
+
+    def html(selectedValue = @selectedValue)
+      
+      puts "#############################################@:#{selectedValue}".red
+      fieldTable = @odb.toFieldTable
+      @selectTag.setItems(fieldTable.column(@showedFieldName, "key")).setValues(fieldTable.column("id", :key))
+      @selectTag.setSelected(selectedValue) if (selectedValue)
+
+      return super()
+
+    end
+    
+    def closeButton()
+      puts "closeButton".red
+      return nil
+    end
+
+    def edit(recordId)
+      puts "recordId: #{recordId}".red
+      dialogView = HDBDialogView.new(recordId, @moduleName, @odb, @oid, @dialogLevel)
+      dialogView.closeButton.connect(:onclick, self, "closeButton", before: 'hdialogView.close()', mode: 'none', id: @oid)
+      dialogView.connect(:onsubmit, self, "html", submit: true, id: @oid, args:[recordId])
+      return dialogView.html(:edit)
+    end
+    
+    def newRecord()
+      nvr = @odb.create # new virtual record
+      dialogView = HDBDialogView.new(nvr.id, @moduleName, @odb, @oid, @dialogLevel)
+      dialogView.closeButton.connect(:onclick, self, "closeButton", before: 'hdialogView.close()', mode: 'none', id: @oid)
+      dialogView.connect(:onsubmit, self, "html", submit: true, id: @oid, args:["#{nvr.id}#"])
+      return dialogView.html(:new)
+    end
+
+end

data/lib/hwidgets/hdbdialogview.rb

@@ -0,0 +1,190 @@
+class HDBDialogView < HWidget
+    
+    attr_accessor :closeButton, :cancelButton, :odb, :modelName, :oid, :dialogLevel
+
+    def initialize(id, moduleName, odb, poid, dialogLevel)
+      super("form", method: "POST")
+      @moduleName = moduleName
+      @modelName = odb.modelName.to_s
+      @oid = hm().malloc(self, poid).obj.object_id.to_s
+      @dialogLevel = dialogLevel + 1
+      @id = id
+      @formFields = self.formFields()
+      @fieldTable = HSpreadFieldTable.new()
+      @fieldTable.addFieldName(0)
+      @fieldTable.addFieldName(1)
+      @tableView = HTableView.new(fieldTable: @fieldTable)
+      @tableView.set(align: "center")
+      @tabs = {}
+      @tabView = HTabView.new(@tabs, @modelName)
+      @odb = odb
+      
+      @dialogHeader = self.dialogHeader()
+      @dialogFooter = self.dialogFooter()
+ 
+    end
+    
+    def self.initByTableView(id, dbTableView)
+      return HDBDialogView.new(id, dbTableView.moduleName, dbTableView.odb, dbTableView.oid, dbTableView.dialogLevel)
+    end
+    
+    def formFields
+      
+      keywords = {
+        name: 'name', 
+        label: 'label',
+        'panel.name': 'panel', 
+        type: 'type',
+        visible: 'visible',
+        default: 'default',
+        hidden: 'hidden',
+        lineedit: 'lineedit',
+        combobox: 'combobox',
+        dbcombobox: 'dbcombobox',
+        radiobutton: 'radiobutton',
+        checkbox: 'checkbox',
+        textarea: 'textarea',
+        dbtable: 'dbtable', 
+        submit: 'submit',
+        show_field: 'show_field',
+        items: 'items',
+        values: 'values',
+        js_function: 'js_function',
+        properties: 'properties',
+        validator: 'validator'
+      }
+      
+      formFields = []
+      hv().viewParsing(@moduleName, @modelName, :form).each do |node| 
+        record = HRecord.new(node.name)
+        keywords.each do |key, value|
+          key = key.to_s
+          nodeValue = node.value(key)
+          record.set(value, nodeValue) if nodeValue
+        end
+        formFields << record
+      end
+      return formFields
+
+    end
+
+
+    def setWidget(row, col, widget, tabName = nil)
+      
+      unless(tabName)
+        @fieldTable.setData(row, col, HRecord.new(widget)) 
+        return
+      end
+      
+      tabName = tabName.downcase.delete(' ')
+      unless(@tabs.key?(tabName))
+        fieldTable = HSpreadFieldTable.new()
+        fieldTable.addFieldName(0)
+        fieldTable.addFieldName(1)
+        tableView = HTableView.new(fieldTable: fieldTable) 
+        @tabs[tabName] = {tabCaption: tabName, tabContain: tableView}
+      end
+      
+      @tabs[tabName][:tabContain].fieldTable.setData(row, col, HRecord.new(widget))
+    end
+
+    def addJsf(formField, jsfList)
+
+      if(jsfList)
+        jsfList.each do |jsf| 
+          formField.addJsFunction(jsf[0], jsf[1], *jsf.drop(2))
+        end
+      end
+
+    end
+
+    def systemRecords()
+      
+      hiddenFormFields = HDivTag.new(class: "system-records") 
+      hiddenFormFields << HHiddenInputTag.new("@modelName", @modelName)
+      hiddenFormFields << HHiddenInputTag.new("@objectId", @odb.object_id)
+      hiddenFormFields << HHiddenInputTag.new("@dialogLevel", @dialogLevel)
+      return hiddenFormFields
+    
+    end
+
+    def setFieldValidator(w, odb)
+      
+      map = Hash.new('length')
+      map[:integer] = 'integer, length'
+      map[:float] = 'real, length'
+      map[:text] = 'length'
+
+      type = odb.fieldProperty(w.name, "type")
+      mandatory = odb.fieldProperty(w.name, "mandatory")
+      type = type.to_sym if type
+      fieldValidator = map[type]
+      fieldValidator += ", mandatory" if mandatory
+      fieldValidator.split(',').uniq.join(',')
+      w.validator = fieldValidator if w.value == 'field'
+      
+    end
+
+    def dialogHeader
+      
+      @closeButton = HWidget.new("button").set(type: "button", class: "close-btn").setInnerHTML("X")
+
+      divHeader = HDivTag.new(class: "header")
+      divHeader << @closeButton
+
+      return divHeader
+
+    end
+    
+    def dialogFooter
+      
+      @cancelButton = HWidget.new("button").set(type: "button", class: "cancel-btn").setInnerHTML("Cancel")
+
+      @okButton = HWidget.new("input").set(type: "submit", class: "ok-btn", value: "Ok")
+
+      divFooter = HDivTag.new(class: "footer")
+      divFooter << @okButton << @cancelButton
+
+      return divFooter
+
+    end
+
+
+    # cols e' il numero di colonne
+    def html(cols = 1)
+      puts "result: #{@id} - #{@modelName}"
+      set(method: "post", action: "submit/params")
+      i = 0
+      @odb = @odb.odb if @odb.class == HRecordPtr
+      @odb.findByOffLine({id: @id})
+      @formFields.each do |w| # w like widget
+        puts "name, type: #{w.name}, #{w.type}".red
+        w.type = w.type.downcase
+        w.visible = w.visible ? w.visible.to_b : true
+        next if(w.visible == false)
+        w.set(:value, @odb.data(w.name)) 
+        w.set("#id", @id)
+        w.set("#dialogLevel", @dialogLevel)
+        self.setFieldValidator(w, @odb)
+        formField = HFormField.new(@moduleName, w, @odb, @oid, @dialogLevel).obj()
+        formField.set(eval(w.properties)) if(w.properties)
+        formField.connect(:onblur, "HInputValidator", "valid?", 
+                          attributes: ':obj.value => fieldValue', # obj.value verra passato attraverso fieldValue
+                          after: 'hdialogView.fieldValidator(obj, response)', getElem: 'none', mode: 'none',
+                          args: {fieldType: w.validator, fieldName: w.name, modelName: @modelName},
+                          id: @oid) if w.validator
+        #formField.addJsFunction(:onblur, "setValue") # non server piu in quanto uso ':obj.value'
+               
+        w.panel += "-#{@dialogLevel}" if w.panel 
+        self.setWidget(i / cols, i % cols, formField, w.panel)
+        i += 1 
+      end
+     
+      self << @dialogHeader << @tableView << @tabView << @dialogFooter << self.systemRecords()
+        
+      divDialog = HDivTag.new(super(), class: "hdialog")
+      return divDialog.html()
+
+    end
+
+end