flukso4r 0.2.0 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/bin/flukso_archive_watts

@@ -94,10 +94,9 @@ if not File.exists?(dbfile)
 end
 
 
-# No authentication by now.
-auth=Flukso::HTTPAuth.new("", "");
+auth=Flukso::TokenAuth.new($CONFIG["ACCESS_TOKEN"]);
 api=Flukso::API.new(auth);
-query=Flukso::QueryReadings.new($CONFIG["ACCESS_KEY"], :hour, :watt)
+query=Flukso::QueryReadings.new($CONFIG["SENSOR_ID"], :hour, :watt)
 begin
   readings=query.execute(api);
 rescue Exception => e

data/bin/flukso_export_db

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# This file is part of fluksobot
+# (c) 2009 Mathias Dalheimer, md@gonium.net
+#
+# FluksoBot is free software; you can 
+# redistribute it and/or modify it under the terms of the GNU General Public 
+# License as published by the Free Software Foundation; either version 2 of 
+# the License, or any later version.
+#
+# FluksoBot is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with FluksoBot; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+# Read the fluksobot location 
+libpath=File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift << libpath 
+#puts "Using libraty path #{$:.join(":")}" 
+
+require 'rubygems'
+require 'optparse'
+require 'ostruct'
+require 'flukso'
+
+###
+## Commandline parser
+#
+class Optparser
+  CODES = %w[iso-2022-jp shift_jis euc-jp utf8 binary]
+  CODE_ALIASES = { "jis" => "iso-2022-jp", "sjis" => "shift_jis" }
+  #
+  # Return a structure describing the options.
+  #
+  def self.parse(args)
+    # The options specified on the command line will be collected in *options*.
+    # We set default values here.
+    options = OpenStruct.new
+    options.inplace = false
+    options.encoding = "utf8"
+    options.verbose = false
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options]"
+      opts.separator ""
+      opts.separator "Specific options:"
+    opts.on("-c", "--config FILE", "The configuration file to use.") do |file|
+      options.config_file = file 
+    end
+    # Boolean switch.
+    opts.on("-f", "--force", "Ignore warnings") do |f|
+      options.force = f 
+    end
+    opts.on("-v", "--verbose", "Run verbosely") do |v|
+      options.verbose = v
+    end
+    opts.on_tail("-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+  end
+  opts.parse!(args)
+  options
+end
+end
+
+###
+## Script startup
+#
+options = Optparser.parse(ARGV)
+$verbose = options.verbose
+$force = options.force
+puts "FluksoBot database setup script."
+if options.config_file == nil
+  puts "Please provide a configuration file... (-h for details)."
+  exit(-1);
+end
+if not File.exists?(options.config_file) 
+  puts " Configuration file #{options.config_file} not found - no database configuration available!"
+  exit(-3);
+else
+  $CONFIG=YAML.load_file(options.config_file);
+  puts "Using this configuration:" if $verbose
+  puts "#{$CONFIG}" if $verbose
+  dbfile=$CONFIG['DB_FILE']
+end
+if $verbose
+  puts " Using database file #{dbfile}"
+end
+# check and expand paths.
+if not File.exists?(dbfile) 
+  puts " Database does not exists. Aborting."
+  exit(-2);
+end
+
+# The database does not exist. Create the DB and populate it with 
+# tables.
+
+db=Flukso::FluksoDB.open($CONFIG["DB_FILE"], $CONFIG["DB_TABLE_NAME"]);
+begin
+  last=db.find_reading_last();
+  puts "Last reading: #{last}"
+rescue Flukso::ElementNotFoundError => e
+  puts "Empty database - not able to provide last reading."
+end
+db.close

data/bin/flukso_query

@@ -55,8 +55,11 @@ class Optparser
       opts.on("-u", "--unit VALUE", "The unit you want to query. Valid queries are: {watt, kwh, eur, aud}") do |unit|
         options.unit = unit 
       end
-      opts.on("-a", "--alias VALUE", "The device alias you want to query.") do |alias_id|
-        options.alias_id = alias_id
+      opts.on("-i", "--sensor-id VALUE", "The sensor ID you want to query.") do |sensor_id|
+        options.sensor_id = sensor_id
+      end
+      opts.on("-a", "--access-token VALUE", "Your access token.") do |access_token|
+        options.access_token = access_token
       end
       # Boolean switch.
       opts.on("-v", "--verbose", "Run verbosely") do |v|
@@ -107,12 +110,12 @@ else begin
   exit(-2);
 end
 end
-alias_id=options.alias_id
+sensor_id=options.sensor_id
+access_token=options.access_token
 
-# No authentication by now.
-auth=Flukso::HTTPAuth.new("", "");
+auth=Flukso::TokenAuth.new(access_token);
 api=Flukso::API.new(auth);
-query=Flukso::QueryReadings.new(alias_id, range, unit)
+query=Flukso::QueryReadings.new(sensor_id, range, unit)
 begin
   readings=query.execute(api);
 rescue Exception => e

data/lib/flukso/api.rb

@@ -22,8 +22,8 @@
 
 module Flukso
   class QueryReadings
-    def initialize(alias_id, timerange=:hour, unit=:watt)
-      @alias_id=alias_id;
+    def initialize(sensor_id, timerange=:hour, unit=:watt)
+      @sensor_id=sensor_id;
       # sanity checks.
       valid_timeranges=[:hour, :day, :month, :year, :night];
       valid_units=[:watt, :kwh, :eur, :aud];
@@ -36,7 +36,7 @@ module Flukso
       if api.class != Flukso::API
         raise  Flukso::General, "Cannot execute query: API object invalid"
       end
-      query_url="#{Flukso::BASE_SENSOR_URL}/#{@alias_id}/#{@timerange}/#{@unit}";
+      query_url="#{Flukso::BASE_SENSOR_URL}/#{@sensor_id}?interval=#{@timerange}&unit=#{@unit}";
       puts "Using query url #{query_url}" if $verbose
       response = api.perform_get(query_url) 
       return wrap_response(response);
@@ -62,21 +62,22 @@ module Flukso
     def initialize(client)
       @client = client
     end
-
+    
     def perform_get(path, options={})
-      Flukso::Request.get(self, path, options)
+      Flukso::Request.get(self, path, options )
     end
 
     def perform_post(path, options={})
-      Flukso::Request.post(self, path, options)
+      Flukso::Request.post(self, path, add_version_header(options))
     end
 
     def perform_put(path, options={})
-      Flukso::Request.put(self, path, options)
+      Flukso::Request.put(self, path, add_version_header(options))
     end
 
     def perform_delete(path, options={})
-      Flukso::Request.delete(self, path, options)
+      Flukso::Request.delete(self, path, add_version_header(options))
     end
+
   end
 end

data/lib/flukso/http_auth.rb

@@ -21,37 +21,57 @@
 
 
 module Flukso
-  class HTTPAuth
+  class TokenAuth
     include HTTParty
     format :plain
 
-    attr_reader :username, :password, :options
+    attr_reader :options
 
-    def initialize(username, password, options={})
-      @username, @password = username, password
-      @options = {:ssl => false}.merge(options)
-      self.class.base_uri "http#{'s' if options[:ssl]}://api.flukso.net"
+    def initialize(access_token)
+      @access_token = access_token
+      #@options = {:ssl => true}.merge(options)
+      self.class.base_uri "#{Flukso::BASE_SENSOR_URL}"
     end
 
+    
     def get(uri, headers={})
-      self.class.get(uri, :headers => headers, :basic_auth => basic_auth)
+      headers=add_auth_header(headers);
+      self.class.get(uri, :headers => headers)
     end
 
     def post(uri, body={}, headers={})
-      self.class.post(uri, :body => body, :headers => headers, :basic_auth => basic_auth)
+      self.class.post(uri, :body => body, :headers => add_auth_header(headers))
     end
 
     def put(uri, body={}, headers={})
-      self.class.put(uri, :body => body, :headers => headers, :basic_auth => basic_auth)
+      self.class.put(uri, :body => body, :headers => add_auth_header(headers))
     end
 
     def delete(uri, body={}, headers={})
-      self.class.delete(uri, :body => body, :headers => headers, :basic_auth => basic_auth)
+      self.class.delete(uri, :body => body, :headers => add_auth_header(headers))
     end
 
     private
-    def basic_auth
-      @basic_auth ||= {:username => @username, :password => @password}
+
+    def add_version_header(headers)
+      if (headers==nil)
+      else
+        headers={"X-Version" => "#{Flukso::API_VERSION}"}.merge(headers);
+      end
+      return headers;
     end
+
+
+    def add_auth_header(headers)
+      if (headers==nil)
+        headers={"X-Version" => "#{Flukso::API_VERSION}"}
+        headers.merge!({"X-Token" => "#{@access_token}"})
+      else
+        headers={"X-Version" => "#{Flukso::API_VERSION}"}.merge(headers);
+        headers={"X-Token" => "#{@access_token}"}.merge(headers);
+      end
+      return headers;
+    end
+
   end
 end

data/lib/flukso.rb

@@ -45,6 +45,7 @@ module Flukso
   class NotFound < StandardError; end
   # Use only the encrypted endpoint.
   BASE_SENSOR_URL = "https://api.flukso.net/sensor"
+  API_VERSION="1.0"
 end
  
 directory = File.expand_path(File.dirname(__FILE__))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: flukso4r
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Mathias Dalheimer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 00:00:00 +01:00
+date: 2010-02-26 00:00:00 +01:00
 default_executable: flukso_query
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,7 @@ files:
 - VERSION
 - bin/flukso_archive_watts
 - bin/flukso_create_db
+- bin/flukso_export_db
 - bin/flukso_query
 - lib/flukso.rb
 - lib/flukso/api.rb