toolhound-ruby 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 365f0baac45b1ec5b6b28fbd679cf71d7f405bad
-  data.tar.gz: 5b7f413f4130392a675606641f1ee5f45a62ea91
+  metadata.gz: 7c0caeb8b12ac9170f28f99f65d227fbd17cffd3
+  data.tar.gz: ddde04f9f3fb97c0beeebe5b83250ca0f2300a79
 SHA512:
-  metadata.gz: 4ab1bf011348d24008412d59fc7581f912e66a969dcc053512cbee943bd26904a1e47e13521dd82be00d364eefbd7cd135ccfe488b50eb9a30ab4a153ae19e2f
-  data.tar.gz: dd830cc1fbd1c5c4ea232843800686891ed4d9f3d536d5e1da58f71c5aaddb7396d67dfca2224ad1eb5b6497ff1f905725032400990dc1c340ecac44fc1cc74a
+  metadata.gz: ce0815e9d2315fe05c9411e2c241f2a49f4f5e211c12bb2aa2a2dff6ef081d965ddfeb68ac12e33e17cab9ec88fd0ea4bb1387ff7f2cbd3978671b200ec2eb4d
+  data.tar.gz: 1f748ccb5c8bb16825528f708e5d26bf813da4f956780d0d530234533b531822a9055a7f2128fb94b990ecca5e8202379a3b5fd761a9cfc039e76020e9d6399f

data/lib/toolhound-ruby.rb

@@ -7,6 +7,8 @@
 # require "nearmiss-ruby/raise_error"
 # require "nearmiss-ruby/version"
 require "tiny_tds"
+require "toolhound-ruby/util"
+
 require "toolhound-ruby/core_ext/string"
 require "toolhound-ruby/configurable"
 # require "nearmiss-ruby/response"
@@ -15,6 +17,16 @@ require "toolhound-ruby/default"
 require "toolhound-ruby/base"
 
 require "toolhound-ruby/project"
+require "toolhound-ruby/inventory"
+require "toolhound-ruby/inventory_item"
+require "toolhound-ruby/rental"
+require "toolhound-ruby/rental_item"
+require "toolhound-ruby/rental_charge"
+
+require "toolhound-ruby/vendor"
+require "toolhound-ruby/manufacturer"
+require "toolhound-ruby/purchase_order"
+
 # require "nearmiss-ruby/util"
 
 module Toolhound

data/lib/toolhound-ruby/authentication.rb

@@ -12,10 +12,6 @@ module Toolhound
       !!(@username && @password && @dataserver)
     end
 
-    # dataserver: 'pbssrvr\sqlexpress',
-    # port:       1433,
-    # username:   'mklooth',
-    # password:   'ToolHound'
 
     def sign_in
       @connection ||= begin

data/lib/toolhound-ruby/base.rb

@@ -1,23 +1,27 @@
 module Toolhound
 
   class Base
+    DB_TYPE_REGEX   = /^(int|dec|var|bol|dte|bin)/
 
-    attr_accessor :attributes
+    include Toolhound::Util
+    attr_accessor :connection
 
     def self.table_name
-      @@table_name
+      @@table_name[self.name]
     end
 
     def self.primary_key
-      @@primary_key
+      @@primary_key[self.name]
     end
 
     def self.table_name=(table_name)
-      @@table_name = table_name
+      @@table_name ||= {}
+      @@table_name[self.name] = table_name
     end
 
     def self.primary_key=(primary_key)
-      @@primary_key = primary_key
+      @@primary_key ||= {}
+      @@primary_key[self.name] = primary_key
     end
 
 
@@ -30,32 +34,265 @@ module Toolhound
       @@rename_attributes ||= {}
     end
 
-    def self.find(id)
-      # table_includes = ""
-      results = query "SELECT TOP(1) * FROM #{table_name} #{table_includes} WHERE #{primary_key} = #{id}"
+    # def self.connection
+    #   @connection ||= Toolhound.connection
+    # end
+    #
+    def initialize(connection, options = {})
+      @connection = connection
+      # @original = attrs
+      # self.attributes = transform_attributes(attrs)
+    end
+    def table_name
+      name = self.class.table_name || demodulize(self.class.name)
+      formatted_table_name(name)
+    end
+    def primary_key
+      id = self.class.primary_key || "int#{demodulize(self.class.name)}ID"
+      formmatted_column_name(id)
+    end
+
+    def locale
+      @locale ||= "EN-US"
+    end
+
+    def default_wheres
+      []
+    end
+
+    def default_selects
+      {}
+    end
+    def default_joins
+      []
+    end
+
+    def all(options = {})
+      options = merge_options({selects: default_selects, joins: default_joins, where: default_wheres}, options)
+      build_and_query options
+    end
+
+    def find(id, options = {})
+      # "tblInventory.bolIsActive = 1 AND tblInventory.bolDeleted = 0 AND tblInventory.intInventoryID = #{id}"
+      # wheres = [] + default_wheres
+      wheres = default_wheres + [{:"#{primary_key}" => id}]
+      options = merge_options({limit: 1, selects: default_selects, joins: default_joins, where: wheres}, options)
+      results = build_and_query options
       results.first
     end
 
-    def self.all(options = {})
-      results = query "SELECT * FROM #{table_name}"
+    def merge_options(defaults, options = {})
+      where   =  options.delete :where
+      selects = options.delete :selects
+      joins   = options.delete :joins
+      defaults[:where]    = (defaults[:where] || []) + (where || [])
+      defaults[:selects]  = defaults[:selects].merge(selects || {})
+      defaults[:joins]    = defaults[:joins] + (joins || [])
+      defaults.merge options
+
+    end
+
+    # def where(wheres, options = {})
+    #
+    #   sql = build_sql(limit: 1, selects: default_selects, joins: default_joins, where: wheres)
+    #
+    # end
+
+    # def find(id)
+    #   # table_includes = ""
+    #   results = query "SELECT TOP(1) * FROM #{table_name} #{table_includes} WHERE #{primary_key} = #{id}"
+    #   results.first
+    # end
+    #
+    # def all(options = {})
+    #   results = query "SELECT * FROM #{table_name}"
+    # end
 
+
+
+    def formatted_table_name(table)
+      table = table.to_s
+      unless /^tbl/i =~ table
+        table = "tbl#{camelize(table, true)}"
+      end
+      camelize(table, false)
+    end
+
+    def formmatted_column_name(column)
+      column = column.to_s
+      camelize(column, false)
+    end
+
+    def build_selects(selects)
+      _build_selects(selects).join(", ")
     end
 
-    def self.query(query)
-      klass = self
+    def _build_selects(selects)
+      arr = []
+      aggs = {
+        count: "COUNT",
+        max: "MAX",
+        min: "MIN",
+        average: "AVERAGE"
+      }
+      selects.each do |table, values|
+
+        values.each do |v|
+          if v.is_a? Hash
+
+          end
+          # select = "#{formatted_table_name(table)}."
+          if v.is_a? Hash
+            select = "#{formatted_table_name(table)}.#{formmatted_column_name(v.first[0])}"
+            options = v.first[1]
+            if options.is_a? Hash
+              if options[:agg]
+                select = "#{aggs[options[:agg]]}(#{select})"
+              end
+              if options[:as]
+                select += " AS #{formmatted_column_name(options[:as])}"
+              end
+            else
+              select += " AS #{formmatted_column_name(options)}"
+            end
+            #
+          else
+            select = "#{formatted_table_name(table)}.#{formmatted_column_name(v)}"
+          end
+          arr << select
+        end
+      end
+      arr
+    end
+
+
+    def build_joins(joins)
+      _build_joins(joins).join(" ")
+    end
+
+    def _build_joins(joins)
+      join_types = {
+        inner: "INNER JOIN",
+        left: "LEFT OUTER JOIN",
+        left_outer: "LEFT OUTER JOIN",
+        left_inner: "LEFT INNER JOIN",
+        right: "RIGHT OUTER JOIN",
+        right_outer: "RIGHT OUTER JOIN",
+        right_inner: "RIGHT INNER JOIN",
+      }
+
+      # joins_query = joins.map do |join|
+      #   type  = join_types[join[:type] || :inner]
+      #   table = formatted_table_name(join[:table])
+      #   on    = join[:on]
+      #
+      #   on_str = on ? "ON #{on}" : ""
+      #   "#{type} #{table} #{on_str}"
+      # end
+      # joins_query.join(" ")
+      joins
+    end
+
+
+    def build_where(wheres)
+      arr = _build_where(wheres)
+      arr.join(" AND ")
+    end
+
+    def _build_where(wheres)
+      arr = []
+      case wheres.class.to_s
+      when "String"
+        return wheres
+      when "Hash"
+        wheres.each do |k, v|
+          table, column = formatted_table_and_column(k)
+          op = :eq
+          if v.is_a? Hash
+            op = v.delete :op
+            v  = v.delete :value
+          end
+
+
+          arr << "#{table}.#{column} #{get_operator(op, v)}"
+          # if v.is_a? Hash
+          #   # key, value = v.first
+          #   # op
+          #   # arr <<
+          #   v.each do |k1, v1|
+          #     arr << "#{formatted_table_name(k)}.#{formmatted_column_name(k1)} = '#{v1}'"
+          #   end
+          # else
+          #   arr << "#{formatted_table_name(table_name)}.#{formmatted_column_name(k)} = '#{v}'"
+          # end
+        end
+      when "Array"
+        wheres.each do |v|
+          arr += _build_where(v)
+        end
+      end
+      arr
+    end
+
+    def get_operator(op, value)
+      operators = {eq: "=", gt: ">", gte: ">=", lt: "<", lte: "<=", ne: "!=", in: "IN", nin: "NOT IN", like: "LIKE", between: "BETWEEN"}
+      ops = operators.values
+      operator = operators[op]
+      unless operator
+        operator = ops.include?(op) ? op : "="
+      end
+
+      if operator == "IN" || operator == "NOT IN"
+        value = "(#{value})"
+      elsif operator == "BETWEEN"
+        value = "'#{value[0]}' AND '#{value[1]}'"
+      else
+        value = "'#{value}'"
+      end
+      "#{operator} #{value}"
+    end
+
+    def formatted_table_and_column(key)
+      key = key.to_s
+      first, second = key.split(".")
+      if first && second
+        [formatted_table_name(first), formmatted_column_name(second)]
+      elsif(first)
+        [table_name, formmatted_column_name(first)]
+      end
+
+    end
+
+    def query(query, options)
+      data    = []
       results = connection.execute(query)
-      results.map do |row|
-        klass.new row
+      results.each(:cache_rows => false) do |row|
+        data << transform_attributes(row)
       end
+      data
     end
 
-    def self.connection
-      @connection ||= Toolhound.connection
+    def build_and_query(options, query_options = {})
+      sql = build_sql(options)
+      results = query(sql, query_options)
     end
 
-    def initialize(attrs = {}, options = {})
-      # @original = attrs
-      self.attributes = transform_attributes(attrs)
+
+    def build_sql(obj)
+      limit   = obj[:limit]
+      selects = obj[:selects] ? build_selects(obj[:selects]) : "*"
+      joins   = obj[:joins] ? build_joins(obj[:joins]) : ""
+      from    = obj[:from]  ? formatted_table_name(obj[:from]) : table_name
+      where   = obj[:where] ? build_where(obj[:where]) : nil
+      order   = obj[:order]
+
+      limit_str   = limit ? "TOP(#{limit})" : ""
+      where_str   = where.length > 0 ? "WHERE #{where}"    : ""
+      order_str   = order ? "ORDER BY #{order}" : ""
+
+      sql = "SELECT #{limit_str} #{selects} FROM #{from} #{joins} #{where_str} #{order_str}"
+      puts sql
+      sql
     end
 
     # def attributes=(hash)
@@ -71,7 +308,11 @@ module Toolhound
       hash = {}
       attrs.each do |k, v|
         key = transform_attribute_key(k)
-        hash[key] = v
+        if hash.include? key
+          hash[:"#{key}1"] = v
+        else
+          hash[key] = v
+        end
       end
       hash
     end
@@ -80,13 +321,16 @@ module Toolhound
       renamed = self.class.renamed_attributes
       if renamed.include? key
         renamed[key].to_sym
-      elsif key == self.class.primary_key
-        :id
       else
       # "varTransferReceiptPrefix"
-        word = key[3..key.length]
-        word.underscore.to_sym
+        if DB_TYPE_REGEX =~ key
+          word = key[3..key.length]
+          underscore(word).to_sym
+        else
+          underscore(key).to_sym
+        end
       end
+
     end
 
   end

data/lib/toolhound-ruby/client.rb

@@ -10,7 +10,7 @@ module Toolhound
   class Client
     include Toolhound::Authentication
     include Toolhound::Configurable
-
+    include Toolhound::Util
     include Toolhound::Client::Projects
     # include Toolhound::Client::Bookmarks
     # include Toolhound::Client::Categories
@@ -74,6 +74,7 @@ module Toolhound
     end
 
 
+
     # Set username for authentication
     #
     # @param value [String] Toolhound-field username
@@ -94,6 +95,94 @@ module Toolhound
       @connection = nil
     end
 
+    def inventory
+      @inventory ||= Toolhound::Inventory.new(connection)
+    end
+
+    def inventory_item
+      @inventory_item ||= Toolhound::InventoryItem.new(connection)
+    end
+
+    def project
+      @project ||= Toolhound::Project.new(connection)
+    end
+
+    def rental
+      @rental ||= Toolhound::Rental.new(connection)
+    end
+
+    def rental_item
+      @rental_item ||= Toolhound::RentalItem.new(connection)
+    end
+    def rental_charge
+      @rental_charge ||= Toolhound::RentalCharge.new(connection)
+    end
+
+    def vendor
+      @vendor ||= Toolhound::Vendor.new(connection)
+    end
+    def manufacturer
+      @vendor ||= Toolhound::Manufacturer.new(connection)
+    end
+    def purchase_order
+      @vendor ||= Toolhound::PurchaseOrder.new(connection)
+    end
+
+
+
+    def query(query, options = {})
+      klass = self
+
+
+
+      results = connection.execute(query)
+      results.map do |row|
+        transform_attributes(row)
+      end
+    end
+
+    def transform_attributes(attrs)
+      hash = {}
+      attrs.each do |k, v|
+        key = transform_attribute_key(k)
+        if hash.include? key
+          hash[:"#{key}1"] = v
+        else
+          hash[key] = v
+        end
+      end
+      hash
+    end
+
+    DB_TYPE_REGEX = /^(int|dec|var|bol|dte|bin)/
+
+    #"SELECT column_name, data_type FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'tblRentalCharge' AND TABLE_SCHEMA='dbo'"
+
+    # "SELECT * FROM information_schema.tables ORDER BY table_name"
+    #
+    # Find project from job number
+    # "SELECT tblEntity.intEntityID, tblEntity.varEntityID AS job_no, tblLocation.intLocationID, tblLocationText.varLocationName  FROM tblEntity INNER JOIN tblLocation ON tblLocation.intEntityID = tblEntity.intEntityID INNER JOIN tblLocationText ON tblLocationText.intLocationID = tblLocation.intLocationID WHERE varEntityID LIKE '%10526.00%' "
+
+    # "SELECT MAX(dteStartDate) AS max_date, MIN(dteStartDate) AS min_date FROM tblRentalCharge WHERE intEntityID  = 100044"
+    #
+    def transform_attribute_key(key)
+      # renamed = self.class.renamed_attributes
+      # if renamed.include? key
+      #   renamed[key].to_sym
+      # elsif key == self.class.primary_key
+      #   :id
+      # else
+      # # "varTransferReceiptPrefix"
+      #   word = key[3..key.length]
+      #   word.underscore.to_sym
+      # end
+      word = key
+      if DB_TYPE_REGEX =~ key
+        word = key[3..key.length]
+      end
+      underscore(word).to_sym
+    end
+
 
     # Wrapper around Kernel#warn to print warnings unless
     # TOOLHOUND_SILENT is set to true.

data/lib/toolhound-ruby/core_ext/string.rb

@@ -1,16 +1,28 @@
 class String
 
-  def underscore()
-    camel_cased_word = self
-    acronym_regex = /#{["REST"].join("|")}/
-    return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
-    word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
-    word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
-    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-    word.tr!("-".freeze, "_".freeze)
-    word.downcase!
-    word
-  end
+  # def underscore()
+  #   camel_cased_word = self
+  #   acronym_regex = /#{["REST"].join("|")}/
+  #   return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+  #   word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
+  #   word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+  #   word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+  #   word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+  #   word.tr!("-".freeze, "_".freeze)
+  #   word.downcase!
+  #   word
+  # end
+  #
+  # def camelize(term, uppercase_first_letter = true)
+  #   string = term.to_s
+  #   if uppercase_first_letter
+  #     string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+  #   else
+  #     string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+  #   end
+  #   string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
+  #   string.gsub!('/'.freeze, '::'.freeze)
+  #   string
+  # end
 
 end

data/lib/toolhound-ruby/inventory.rb

@@ -8,12 +8,90 @@ module Toolhound
   class Inventory < Base
     # attr_accessor :owner, :name, :id
 
-    self.table_name   = "tblInventory"
-    self.primary_key  = "intInventoryID"
+    # self.table_name   = "tblInventory"
+    # self.primary_key  = "intInventoryID"
+
+
+    def default_selects
+      selects = {
+        inventory: ["intInventoryID", "intCategoryID", "intSubCategoryID", "intManufacturerID", "intVendorID", "dteCreatedDate", "dteModifiedDate"],
+        inventory_text: ["varPartNo", "varDescription", "txtNotes", {varUserField1: "varGlRevenue"}, {varUserField2: "varGlCOGSCode"}, {varUserField3: "varPhaseCode"}],
+        unit_of_measure_text: ["varUnitOfMeasure"],
+        category: ["varCategory"],
+        sub_category: ["varCategory"]
+      }
+    end
+    def default_joins
+      arr = []
+      arr << "INNER JOIN tblInventoryType ON tblInventory.intInventoryTypeID = tblInventoryType.intInventoryTypeID"
+      arr << "INNER JOIN tblInventoryText ON (tblInventoryText.intInventoryID = tblInventory.intInventoryID AND tblInventoryText.varLocaleID = '#{locale}')"
+      arr << "LEFT OUTER JOIN tblUnitOfMeasureText ON (tblUnitOfMeasureText.intUofMID = tblInventory.intUofMID )"
+      arr << "LEFT OUTER JOIN tblCategoryText AS tblCategory ON (tblCategory.intCategoryID = tblInventory.intCategoryID AND tblCategory.varLocaleID = '#{locale}')"
+      arr << "LEFT OUTER JOIN tblCategoryText AS tblSubCategory ON (tblSubCategory.intCategoryID = tblInventory.intSubCategoryID AND tblSubCategory.varLocaleID = '#{locale}')"
+    end
+
+    def default_wheres
+      [{bolIsActive: 1}, {bolDeleted: 0}]
+    end
+    # include_selects tblInventoryText: [:varPartNo, :varDescription, :txtNotes ],
+    #                 tblInventory: [:intInventoryID, :intCategoryID]
+    # def selects
+    #   arr = build_selects(selects)
+    #
+    #   arr.join(", ")
+    # end
+
+
+    # def joins
+    #   # LEFT OUTER JOIN tblInventoryID ON tblInventoryID.intInventoryID = tblInventory.intInventoryID
+    #   [
+    #     {type: :inner, table: :inventory_type, on: "intInventoryTypeID"},
+    #     {type: :inner, table: :inventory_text, on: ["intInventoryTypeID", varLocaleID: locale]},
+    #     {type: :left_outer, table: :unit_of_measure_text, on: "intUofMID"},
+    #     {type: :left_outer, table: :category_text, on: ["intUofMID", varLocaleID: locale], as: :category},
+    #
+    #   ]
+    #   arr.join(" ")
+    # end
+
+    def build_join(join)
+      join_types = {
+        inner: "INNER JOIN",
+        left: "LEFT OUTER JOIN",
+        left_outer: "LEFT OUTER JOIN",
+        left_inner: "LEFT INNER JOIN",
+        right: "RIGHT OUTER JOIN",
+        right_outer: "RIGHT OUTER JOIN",
+        right_inner: "RIGHT INNER JOIN",
+      }
+
+      type  = join_types[join[:type] || :inner]
+      table = formatted_table_name(join[:table])
+
+      table_str = "#{table} "
+      if join[:as]
+        table = formatted_table_name(join[:as])
+        table_str += "AS #{table} "
+      end
+
+      on = join[:on]
+      case on.class.to_s
+      when "String"
+
+      end
+
+      # on_str = on ? "ON #{on}" : ""
+      "#{type} #{table_str} #{on_str}"
+
+
+    end
 
     # includes :tblInventoryText,
     # rename_attributes intLocationID: 'location_id'
 
-    
+
+
+
+
   end
 end

data/lib/toolhound-ruby/project.rb

@@ -8,10 +8,33 @@ module Toolhound
     self.table_name   = "tblLocation"
     self.primary_key  = "intLocationID"
 
-    # rename_attributes intLocationID: 'location_id'
-    def inventory_items
+    def default_selects
+      #{ }"SELECT tblEntity.intEntityID, tblEntity.varEntityID AS job_no, tblLocation.intLocationID, tblLocationText.varLocationName  FROM tblEntity INNER JOIN tblLocation ON tblLocation.intEntityID = tblEntity.intEntityID INNER JOIN tblLocationText ON tblLocationText.intLocationID = tblLocation.intLocationID WHERE varEntityID LIKE '%10526.00%'"
+      {
+        location:       [:int_location_id, :dte_created_date, :dte_modified_date],
+        location_text:  [:var_location_name],
+        entity:         [:int_entity_id, var_entity_id: :job_no ]
+      }
+    end
+
+    def default_joins
+      arr = []
+      arr << "INNER JOIN tblEntity ON (tblEntity.intEntityID = tblLocation.intEntityID)"
+      arr << "INNER JOIN tblLocationText ON (tblLocationText.intLocationID = tblLocation.intLocationID)"
+
+      arr
+    end
 
+    def find_by_entity_id(id)
+      all(limit: 1, where: [{int_entity_id: id}]).first
     end
 
+    def find_by_job_no(job_no)
+      all(limit: 1, where: [{"entity.var_entity_id" => {value: "%#{job_no}%", op: :like} }]).first
+
+    end
+
+    # rename_attributes intLocationID: 'location_id'
+
   end
 end

data/lib/toolhound-ruby/version.rb

@@ -1,3 +1,3 @@
 module Toolhound
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toolhound-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Markus Klooth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tiny_tds