lewt 0.5.12

data/lib/extensions/simple-expenses.rb

@@ -0,0 +1,112 @@
+require "csv"
+
+# Author::    Jason Wijegooneratne  (mailto:code@jwije.com)
+# Copyright:: Copyright (c) 2014 Jason Wijegooneratne
+# License::   MIT. See LICENSE.md distributed with the source code for more information.
+
+
+module LEWT
+
+  # The Simple Expenses LEWT Extensions allows you to manage you expenses in a CSV file. The CSV
+  # file itself must conform to the following specification:
+  #
+  # ===Row Indexes:
+  # [0] Date 
+  # [1] Description 
+  # [2] Context 
+  # [3] Cost
+  #
+  # The key <tt>expenses_filepath</tt> can be added to your settings file to change the location where this extension looks for the CSV. 
+
+  class SimpleExpenses < LEWT::Extension
+    
+    # Registers this extension
+    def initialize
+      options = {
+        :include_own => {
+          :definition => "toggles including own business expenses from csv file",
+          :default => false,
+          :short_flag => "-i"
+        }
+      }
+      super({:cmd => "expenses", :options => options })
+    end
+
+    # Extracts data from the expenses CSV file.
+    # options [Hash]:: The options hash passed to this function by the Lewt program.
+    def extract( options )
+      @targets = get_matched_customers( options[:target] )
+      @dStart =  options[:start]
+      @dEnd = options[:end]
+      @category = 'Expenses'
+      @include_own_expenses = options[:include_own]
+      exFile = lewt_settings["expenses_filepath"]
+      return get_expenses ( exFile )
+    end
+
+
+    # Read file at filepath and parses it expecting the format presented in this classes header.
+    # filepath [String]:: The CSV filepath as a string.
+    def get_expenses ( filepath )
+      # ROWS:
+      # [0]Date [1]Description [2]Context [3]Cost
+      count = 0
+      data = LEWT::LEWTBook.new
+      CSV.foreach(filepath) do |row|
+        if count > 0
+          date = Time.parse(row[0])
+          desc = row[1]
+          context = row[2]
+          cost = row[3].to_f * -1
+          if self.is_target_date?( date ) == true && self.is_target_context?(context) == true
+            # create ledger entry and append to books
+            row_data = LEWT::LEWTLedger.new({
+                                         :date_start => date, 
+                                         :date_end => date, 
+                                         :category => @category, 
+                                         :entity => context,
+                                         :description => desc,
+                                         :quantity => 1, 
+                                         :unit_cost => cost
+                                       })
+            data.push(row_data)       
+          end
+        end
+        # increment our row index counter
+        count += 1
+      end
+
+      # return our data as per specification!
+      return data
+    end
+
+    # Checks whether event date is within target range
+    # date [DateTime]:: The date to check
+    # returns: Boolean
+    def is_target_date? ( date ) 
+      d = date.to_date
+      check = false
+      if d >= @dStart.to_date && d <= @dEnd.to_date
+        check = true
+      end
+      return check
+    end
+    
+    # Checks if the context field in the CSV matches any of our target clients names or alias'
+    # context [String]:: The context field as a string.
+    def is_target_context?(context)
+      match = false
+      @targets.each do |t|
+        reg = [ t['alias'], t['name'] ]
+        if @include_own_expenses == true
+          reg.concat [ @enterprise["alias"], @enterprise["name"] ]
+        end
+        regex = Regexp.new( reg.join("|"), Regexp::IGNORECASE )
+        match = regex.match(context) != nil ? true : false;
+        break if match != false
+      end
+      return match
+    end
+
+  end
+end

data/lib/extensions/simple-invoices.rb

@@ -0,0 +1,93 @@
+require "yaml"
+require "securerandom"
+
+# Author::    Jason Wijegooneratne  (mailto:code@jwije.com)
+# Copyright:: Copyright (c) 2014 Jason Wijegooneratne
+# License::   MIT. See LICENSE.md distributed with the source code for more information.
+
+# The Billing LEWT Extension handles processing invoices from extracted data and returns them as a hash
+# for rendering.
+
+module LEWT
+
+  class SimpleInvoices < LEWT::Extension
+    
+    attr_reader :data
+    
+    # Sets up this extensions command
+    def initialize
+      super({:cmd => "invoice"})
+    end
+    
+    # Processes the provided extract data into an invoice for the given targets.
+    # options [Hash]:: An hash containing run-time options passed to this extension by LEWT.
+    # data [LEWTBook]:: A hash-like object containing all the extracted data in the LEWTLedger format.
+    # returns [Array]: The invoice data as an array of hashes.
+    def process ( options, data )
+      matchData = get_matched_customers( options[:target] )
+      bills = Array.new
+      matchData.each do |client|
+        bills.push( generateBill( client, data) )
+      end
+      return bills
+    end
+
+    protected 
+    
+    # Generates a UID for this invoice based of the customer it is being sent to
+    def generate_id
+      if !lewt_settings.has_key?("invoice_id_counter")
+        self.write_settings("settings.yml", "invoice_id_counter", 0)
+      end
+      id = lewt_settings["invoice_id_counter"].to_i + 1
+      self.write_settings("settings.yml", "invoice_id_counter", id)
+      return "#{id.to_s}-" + SecureRandom.hex(4)
+    end
+
+    # Generates a bill for the given client.
+    # client [Hash]:: The client to calculate the invoice for.
+    # data [LEWTBook]:: The data preloaded into the LEWTBook format.
+    # returns [Hash]: The invoice data as a hash.  
+    def generateBill(client, data)
+      bill = {
+        "date_created" => DateTime.now.strftime("%d/%m/%y"),
+        "id" => generate_id,
+        # "date_begin"=> @events.dateBegin.strftime("%d/%m/%y"),
+        # "date_end"=> @events.dateEnd.strftime("%d/%m/%y"),
+        "billed_to" => client,
+        "billed_from" => enterprise,
+        "items" => [
+                    # eg: { description, duration, rate, total
+                   ],
+        "sub-total" => 0,
+        "tax" => nil,
+        "total" => nil
+      }    
+      # loop events and filter for requested entity (client)
+      data.each do |row|
+        if row[:entity] == client["name"]
+          item = {
+            "description" => row[:description],
+            "duration" => row[:quantity],
+            "rate" => row[:unit_cost],
+            "total" => row[:total] < 0 ? row[:total] * -1 : row[:total],
+            "start" => row[:date_start].strftime("%d/%m/%y %l:%M%P"),
+            "end" => row[:date_end].strftime("%d/%m/%y %l:%M%P")
+          }
+          bill["items"].push( item );
+          bill["sub-total"] += item["total"]
+        end
+      end  
+      bill["sub-total"] = bill["sub-total"].round(2)
+      bill["tax"] = (bill["sub-total"] * enterprise["invoice-tax"]).round(2)
+      bill["total"] = (bill["sub-total"] + bill["tax"]).round(2)
+      
+      return bill;
+    end
+
+  end
+
+end
+
+
+

data/lib/extensions/simple-milestones.rb

@@ -0,0 +1,102 @@
+require "csv"
+
+# Author::    Jason Wijegooneratne  (mailto:code@jwije.com)
+# Copyright:: Copyright (c) 2014 Jason Wijegooneratne
+# License::   MIT. See LICENSE.md distributed with the source code for more information.
+
+
+module LEWT
+
+  # Extracts milestone payment data from a CSV file.
+  #
+  # ===Row Indexes:
+  # [0] Id 
+  # [1] Date
+  # [2] Description
+  # [3] Context
+  # [4] Amount
+  #
+  # The key <tt>milstones_filepath</tt> can be added to your settings file to change the location where this extension looks for the CSV. 
+
+  class SimpleMilestones < LEWT::Extension
+    
+    # Sets up this extension and regsters its run-time options.
+    def initialize
+      @category = "Milestone Income"
+      super({:cmd => "milestones"})
+    end
+
+    # Extracts data from the milestones CSV file.
+    # options [Hash]:: The options hash passed to this function by the Lewt program.
+    def extract( options )
+      matchData = get_matched_customers( options[:target] )
+      @dStart =  options[:start].to_date
+      @dEnd = options[:end].to_date
+      @targets = self.get_matched_customers(options[:target])
+      exFile = lewt_settings["milestones_filepath"]
+      return get_milestones ( exFile )
+    end
+
+    # Read file at filepath and parses it expecting the format presented in this classes header.
+    # filepath [String]:: The CSV filepath as a string.
+    def get_milestones ( filepath )
+      # ROWS:
+      # [0]Id [1]Date [2]Description [3]Context [4]Amount
+      count = 0
+      data = LEWT::LEWTBook.new
+
+      CSV.foreach(filepath) do |row|
+        if count > 0
+          id = row[0]
+          date = Time.parse( row[1] )
+          desc = row[2]
+          context = row[3]
+          amount = row[4].to_f
+
+          if self.is_target_date?( date ) == true && self.is_target_context?(context) == true
+            # create ledger entry and append to books
+            row_data = LEWT::LEWTLedger.new({
+                                         :date_start => date, 
+                                         :date_end => date, 
+                                         :category => @category, 
+                                         :entity => context,
+                                         :description => desc,
+                                         :quantity => 1, 
+                                         :unit_cost => amount
+                                       })
+            data.push(row_data)
+          end
+        end
+        # increment our row index counter
+        count += 1
+      end
+      return data
+    end
+
+    # Checks if the context field in the CSV matches any of our target clients names or alias'
+    # context [String]:: The context field as a string.
+    def is_target_context?(context)
+      match = false
+      @targets.each do |t|
+        reg = [ t['alias'], t['name'] ]
+        regex = Regexp.new( reg.join("|"), Regexp::IGNORECASE )
+        match = regex.match(context) != nil ? true : false;
+        break if match != false
+      end
+      return match
+    end
+
+    # Checks whether event date is within target range
+    # date [DateTime]:: The date to check
+    # returns: Boolean
+    def is_target_date?(date) 
+      d = date.to_date
+      check = false
+      if d >= @dStart && d <= @dEnd
+        check = true
+      end
+      return check
+    end
+    
+  end
+end

data/lib/extensions/simple-reports.rb

@@ -0,0 +1,81 @@
+# Author::    Jason Wijegooneratne  (mailto:code@jwije.com)
+# Copyright:: Copyright (c) 2014 Jason Wijegooneratne
+# License::   MIT. See LICENSE.md distributed with the source code for more information.
+
+module LEWT
+
+  # The Reports LEWT Extension processes ledger data into a brief report.
+
+  class SimpleReports < LEWT::Extension
+    
+    # Registers this extension.
+    def initialize
+      super({:cmd => "report"})
+    end
+
+    # Called on Lewt process cycle and uses the ledger data to compose a report.
+    # options [Hash]:: The options hash passed to this function by the Lewt program.
+    # data [LEWTBook]:: The data in LEWTBook format
+    def process ( options, data )
+      targets = get_matched_customers( options[:target] )
+      return make_report(targets, data)
+    end
+
+    # This method handles the bulk of the calculation required in compiling the report.
+    # targets [Hash]:: The target client(s) to operate on
+    # data [LEWTBook]:: The data in LEWTBook format
+    def make_report ( targets, data )
+      report = {
+        "date_created" => DateTime.now.strftime("%d/%m/%y"),
+        "included_customers" => targets,
+        "revenue" => 0,
+        "expenses" => 0,
+        "income" => 0,
+        "taxes" => Array.new,
+        "hours" => 0
+      }
+      data.each do |row|        
+        if row[:category].downcase.match /income/
+          report["revenue"] += row[:total]
+          # check if category Hourly Income. If so add quantity to our 'hours' counter.
+          if row[:category].downcase.match /hourly/
+            report["hours"] += row[:quantity]
+          end
+        elsif row[:category].downcase.match /expense/
+          report["expenses"] += row[:total]
+        end 
+      end
+      
+      # remember expenses is a negative amount to begin with so don't subtract it!
+      report["income"] = report["revenue"] + report["expenses"]
+      tax_levees = enterprise["tax_levees"]
+      tax_total = 0
+
+      if tax_levees != nil
+        tax_levees.each do |tax|
+          if tax["applies_to"] == "income"
+            # do income tax
+            if report["income"] > tax["lower_threshold"]
+              taxable = [ report["income"], tax["upper_threshold"]].min - tax["lower_threshold"]
+              damage = (taxable * tax["rate"] + ( tax["flatrate"] || 0 )).round(2)
+              tax_total += damage
+              report["taxes"].push({ "amount" => damage, "name" => tax["name"], "rate" => tax["rate"] })
+            end
+          elsif tax["applies_to"] == "revenue"
+            # do GST's
+            damage = report["revenue"] * tax["rate"] + ( tax["flatrate"] || 0 )
+            tax_total += damage
+            report["taxes"].push({ "amount" => damage, "name" => tax["name"], "rate" => tax["rate"] })
+          end
+        end
+      end
+      report["bottom_line"] = (report["income"] - tax_total).round(2)
+      return report
+    end
+
+    def calculate_income_tax (income, tax)
+      
+    end
+
+  end
+end

data/lib/extensions/store.rb

@@ -0,0 +1,81 @@
+require "yaml"
+
+# Author::    Jason Wijegooneratne  (mailto:code@jwije.com)
+# Copyright:: Copyright (c) 2014 Jason Wijegooneratne
+# License::   MIT. See LICENSE.md distributed with the source code for more information.
+
+
+module LEWT
+
+  # The Store LEWT Extension handles persisting data across sessions. It hooks into the 'process' operation to
+  # obtain the raw extract data, likewise it hooks into 'render' to get the process data. Whilst in 'render' it
+  # also handles writing the data to the file-system, so to save data you must invoke it with the --render flag!
+  # The data is saved to some configurable paths (see source code).
+  #
+  # Furthermore store can also re-extract previously persisted data from the file system for re-use! This is handy
+  # if you need to re-generate some output (ie: an invoice that required a quick edit), or if you would like to use
+  # store data built up overtime for bulk operations such as analytics & reporting.
+
+  class Store < LEWT::Extension
+    
+    # Sets up this extensions command name and run-time options.
+    def initialize
+      options = {
+        :store_filename => {
+          :definition => "File name to save as",
+          :type => String
+        },
+        :store_hook => {
+          :definition => "Tell store whether to save either the 'extract' or 'process' data",
+          :default => "process",
+          :type => String
+        }
+      }
+      super({:cmd => "store", :options => options})
+    end  
+
+    # This method is not yet implemented. This method (should) extracts previously stored data for reuse.
+    # options [Hash]:: A hash that is passed to this extension by the main LEWT program containing ru-time options.
+    def extract( options )
+      
+    end
+    
+    # Captures the extract data and converts it to a YML string storing it as a property on this object.
+    # Returns an empty array so as not to interupt the process loop.
+    # options [Hash]:: A hash that is passed to this extension by the main LEWT program containing ru-time options.
+    # data [Hash]:: The extracted data as a hash.
+    def process( options, data )
+      @extractData = data.to_yaml
+      return []
+    end
+
+    # Captures proess data and converts it to a YML string. This method also handles the
+    # actual writing of data to the file system. The options 'store_hook' toggles exract or
+    # process targeting.
+    # options [Hash]:: A hash that is passed to this extension by the main LEWT program containing ru-time options.
+    # data [Array]:: The processed data as an array of hashes.
+    def render( options, data )
+      @processData = data.to_yaml
+      name = options[:store_filename]
+      yml = options[:store_hook] == "extract" ? @extractData : @processData
+      name != nil ? store(yml, name ) : [yml]
+    end
+
+    protected
+    
+    # Writes the given YAML string to a file at path/name.yml, this method will overwrite the
+    # file if it already exists.
+    # yml [String]:: A YAML string of data.
+    # path [String]:: The path to store too.
+    # name [String]:: The name of the file to save as.
+    def store ( yml, name  )
+      storefile = File.new( name, "w")
+      storefile.puts(yml)
+      storefile.close
+      return [yml]
+    end
+
+  end
+
+
+end